textutils-1.12/ 40777 74504 13 0 5771033602 12472 5ustar meyeringusertextutils-1.12/COPYING100666 21570 13 43076 5022247405 12577 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. textutils-1.12/COPYING.LIB100666 74504 13 61257 5455130113 14254 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! textutils-1.12/ChangeLog100644 74504 13 216702 5771033454 14412 0ustar meyeringuserSun Jun 18 09:15:57 1995 Jim Meyering (meyering@comco.com) * Version 1.12. * md5sum.c (process_buffer): Copy values from struct into individual local variables before performing computation on them, then copy results back into returned struct. Solely for better optimization by compilers that can't keep struct members in registers. From Ulrich Drepper. Thu Jun 15 22:09:14 1995 Jim Meyering (meyering@comco.com) * md5sum.c: Remove unnecessary uses of `defined' in #if* tests. Don't use #elif. Some older compilers don't grok it. (split_3): New function to parse out sum, flag, and filename when reading check file. (hex_digits): Remove length parameter since string parameter is now nul-terminated. (main): Don't allocate separate arrays for filename and sum when checking. Get pointers into line buffer with split_3 instead of using sscanf. (main): Treat `no file args' just like `-' when not checking or using strings. (hex_digits): Unprotoize. * md5sum.c (main): Don't use a separate loop to convert to lower case. Suggested by Ulrich Drepper. (CLOSE): New macro. (md5_file): Use it. From Ulrich Drepper. * md5sum.c: Don't include values.h. [__P]: Undefine it. * md5sum.c: [UNIX || unix]: Also test __UNIX__, __unix__, and _POSIX_VERSION. Reported by Arne H. Juul. Tue Jun 13 21:20:10 1995 Jim Meyering (meyering@comco.com) * tr.c [NDEBUG]: Define it to disable assertions. Some systems have a broken header. (is_char_class_member): Set a variable in each branch of switch stmt and return that value after the switch (rather than returning directly from every branch). (unquote): More int->size_t changes. (build_spec_list): More int->size_t changes. Be very careful about comparison now that variables are unsigned: Use i + 2 < len rather than i < len - 2. The latter didn't work for len < 2. Caught early thanks to a thorough regression test suite. Mon Jun 12 23:07:59 1995 Jim Meyering (meyering@comco.com) * sort.c (xfclose): Don't try to flush stdin, only stdout. Otherwise, at least Ultrix-4.3's fflush would return EOF. Reported by Jim Blandy (jimb@cyclic.com). * tr.c (non_neg_strtol): Don't compare signed and unsigned. [struct Spec_list] (indefinite_repeat_element): New member. Use size_t rather than int or unsigned long where reasonable. (get_spec_status): Make interface cleaner. (get_s1_spec_status): New function. (get_s2_spec_status): New function. (validate): Use new functions instead of get_spec_status. Sun Jun 11 00:39:50 1995 Jim Meyering (meyering@comco.com) * md5sum.c: New file. From Ulrich Drepper. * md5-test.rfc: New file. * Makefile.in: (PROGS): Add md5sum. (check): Run a recursive make in each subdirectory. * man/Makefile.in: (MANFILES): Add md5sum.1. * src/Makefile.in: (SOURCES): Add md5sum.c. (OBJECTS): Add md5sum.o. (PROGS): Add md5sum. (check): Add basic checks for md5sum. (md5sum): Add dependency and link rule. (DISTFILES): Add md5-test.rfc. * tr.c (look_up_char_class, append_char_class, append_equiv_class): Use const attribute when appropriate. Sun May 28 14:48:58 1995 Jim Meyering (meyering@comco.com) * join.c: Overhauled to make -a1 and -a2 options work. Passed all tests in a fairly thorough test suite. Reported by Michael Hasselberg (mikelh@zonta.ping.de). Sat May 27 00:35:47 1995 Jim Meyering (meyering@comco.com) * tail.c (main): Remove dcl of and statements that set now-unused variable. * system.h [!STDC_HEADERS && HAVE_MEMORY_H]: Include memory.h. Without this, SunOS doesn't get type for memchr. Reported by Kaveh Ghazi. Thu May 25 00:06:50 1995 Jim Meyering (meyering@comco.com) * tail.c (tail_lines): Change one more `long' to `off_t'. Otherwise, tail didn't work on NetBSD. From Arne H. Juul. * csplit.c [struct control]: Change type of `repeat' to unsigned long to avoid conversion warning. Sun May 21 07:50:00 1995 Jim Meyering (meyering@comco.com) * Makefile.in (.PHONY): TAGS is not a phony target. From Franc,ois. * xstrtol.c (__strtol): Remove prototype altogether. Move inclusion of xstrtol.h back so that it follows system headers. * Version 1.11.2. Sat May 20 06:44:14 1995 Jim Meyering (meyering@comco.com) * join.c (ADD_FIELD): Declare in K&R style, not ANSI. From Kaveh Ghazi. * xstrtol.c: Define NDEBUG for systems with losing assert.h. (__strtol): Add __unsigned to prototype and use __P. Move inclusion of xstrtol.h to precede prototype. From Kaveh Ghazi. * memmove.c: Include config.h for definition of const. From Kaveh Ghazi. * All Makefile.in (install-exec, install-exec): New targets. From Karl Berry. * tr.c (look_up_char_class): Take a string length argument -- required because the argument is a string that is *not* NUL-terminated. Use strncmp, not strcmp and add string lengths comparison. (append_char_class): Update caller. Before this change, tr '[:upper:]' '[:lower:]' read one uninitialized byte. From Andreas Schwab. * split.c (next_file_name): Move dcls of file-scope variables into this function. Don't rely on arithmetic being two's complement. * paste.c [CLOSED, ENDLIST]: Don't cast constants to FILE pointers. Instead, declare two FILE structs and use their addresses. * csplit.c (record_line_starts): Remove set-but-not-used, file-scope variable. Sat May 13 08:57:20 1995 Jim Meyering (meyering@comco.com) * all source files (usage): Include one- or two-line synopsis in --help output. From Karl Berry. * lib/Makefile.in [.c.o]: Remove -I. since safe-l?stat.h are no longer used. Wed May 10 22:26:35 1995 Jim Meyering (meyering@comco.com) * Version 1.11.1 Sun May 7 13:35:49 1995 Jim Meyering (meyering@comco.com) * all Makefile.in (maintainer-clean): Renamed from realclean per GNU Standards. Thu May 4 23:15:58 1995 Jim Meyering (meyering@comco.com) * sort.c (main): Use stat, not safe_stat. The latter was unnecessary. Don't include safe-stat.h. * lib/Makefile.in (DISTFILES): Remove safe-xstat.hin. Remove all associated rules. safe-l?stat.h are no longer used. * sort.c Don't hard-code /tmp. [DEFAULT_TMPDIR]: Use this instead. * tac.c (save_stdin): Likewise. * sort.c (set_ordering): Properly parse arguments like `+x.yn'. Reported by John Salmon (johns@mullet.anu.edu.au). Patch from Mike Haertel. Wed Apr 26 23:48:13 1995 Jim Meyering (meyering@comco.com) * sort.c (tempname): AND-off high bits of pid so that its decimal string representation is no longer than five digits. From Hans Verkuil (hans@wyst.hobby.nl). Thu Apr 20 23:09:33 1995 Jim Meyering (meyering@comco.com) * expand.c (add_tabstop): Give correct size when reallocating tab_list buffer. From Geoff Odhner (geoff@franklin.com). Reproduce with expand --t=`perl -e "print join (',', (1..300));"`. Tue Apr 18 22:57:43 1995 Jim Meyering (meyering@comco.com) * configure.in: (AC_OUTPUT): Use echo, not date, to avoid creating unnecessary conflicts for people using version control software like RCS and CVS. (AC_ARG_PROGRAM): Use it. Thu Apr 13 23:22:57 1995 Jim Meyering (meyering@comco.com) * head.c: Remove block of redundant comments describing options. (usage): Remove reference to -l option. It's not valid. * od.c (write_block): Declare index I as unsigned int, not int. (get_lcm): Likewise. (dump_strings): Likewise. (main): Likewise. (dump): Cast BYTES_PER_BLOCK to off_t in MIN expression. (dump_strings): Declare bufsize to be of type size_t, not int. * split.c (next_file_name): Don't reuse X as an index. Declare new variable I instead. Sat Mar 25 15:07:23 1995 Jim Meyering (meyering@comco.com) * csplit.c: Declare as `unsigned int' all variables that were just `unsigned'. (make_filename): Change type of arg to unsigned int. (split_file): Change type of indices to unsigned int. Thu Mar 16 22:05:05 1995 Jim Meyering (meyering@comco.com) * od.c (main): Detect and fail when argument to -N is too large to fit in an off_t. Sun Mar 12 12:02:39 1995 Jim Meyering (meyering@comco.com) * configure.in (AC_REPLACE_FUNCS): Add memcmp.c. Remove check for sizeof long. * linebuffer.h: Undefine __P before defining it. * long-options.h: Likewise. * xstrtol.h: Likewise. * memcpy.c: New file. * lib/Makefile.in (SOURCES): Add memcpy.c. Fri Mar 10 21:14:11 1995 Jim Meyering (meyering@comco.com) * src/*.c: Update Copyright dates. Sat Feb 11 07:31:08 1995 Jim Meyering (meyering@comco.com) * system.h: Remove index/rindex and bcmp/bcopy/bzero references. Separate errno declaration from STDC_HEADERS. * wc.c (wc): For efficiency, handle separately the cases in which words need not be counted. Suggested by Karl Heuer. * wc.c (wc): Don't overcount the number of bytes when reading from a regular file on stdin with file pointer not at BOF. From Karl Heuer . Before, the command `(dd ibs=99k skip=1; wc -c) < /etc/group' made wc wrongly output the size of the file. Now it outputs `0'. Sat Jan 28 07:07:23 1995 Jim Meyering (meyering@comco.com) * cat.c (cat): Use memmove rather than bcopy. * csplit.c (load_buffer): Use memcpy rather than bcopy. (extract_regexp): Use strrchr, not rindex. * fmt.c (isopen, isclose, isperiod): Use strchr, not index. (flush_paragraph): Use memmove instead of bcopy. * fold.c (fold_file): Use memmove instead of bcopy. * od.c (decode_format_string): Use memmove instead of bcopy. [EQUAL_BLOCKS]: Use memcmp, not bcmp. (parse_old_offset): Use strchr, not index. (dump): Use memset, not bzero. * sort.c (checkfp, mergefps): Use memcpy instead of bcopy. (fillbuf): Use memmove instead of bcopy. * split.c (main): Use memset, not bzero. (line_bytes_split): Use memmove instead of bcopy. * tac.c (tac): Use memmove instead of bcopy. (output): Use memcpy instead of bcopy. * tail.c (pipe_lines, pipe_bytes): Use memcpy instead of bcopy. * tr.c (substr): Use memcpy instead of bcopy. (card_of_complement, set_initialize): Use memset, not bzero. * tr.c (substr): Don't allocate a byte for trailing NUL in result since the result needn't be NUL-terminated. Don't NUL terminate it. * configure.in (AC_REPLACE_FUNCS): Check for memmove and memcpy, not bcopy. (AC_CHECK_FUNCS): Add strchr and strrchr. * lib/Makefile.in (SOURCES): Add memmove.c and memcpy.c. * memmove.c: New file. * memcpy.c: New file. Tue Jan 24 22:18:19 1995 Jim Meyering (meyering@comco.com) * fmt.c (copy_rest): Replace `||' with `&&'. Before, a paragraph not followed by a newline would be followed by data copied from uninitialized storage. Repeat by `printf abc|fmt|od -ac'. Reported by Franc,ois Pinard. * od.c: Rename macros with FP_ prefix. Use FLOAT_ instead. AIX-2.2.1 declares a typedef, FP_DOUBLE, that conflicted. Be careful to use off_t instead of explicit `unsigned long'. Otherwise, systems like 4.4BSD lose on calls to fseek that expect off_t (which is long long on that system). (parse_old_offset): Use xstrtoul (main): Likewise. * src/Makefile.in (od.o, tail.o): Depend on ../lib/strtol.h. Mon Dec 19 22:13:55 1994 Jim Meyering (meyering@comco.com) * tail.c (numerous functions): Give char* filename arguments the const attribute. * lib/Makefile.in (SOURCES): Remove xwrite.c. It was no longer used. Add xstrtol.c and xstrtoul.c. (OBJECTS): Likewise for .o files. (DISTFILES): Add error.h and xstrtol.h and xstrtoul.h. * lib/Makefile.in (DISTFILES): Remove safe-xstat.cin. (distclean): Remove references to safe-l?stat.c. Remove all related rules and dependencies. * src/Makefile.in: $(OBJECTS): Depend on ../lib/error.h. Thu Dec 15 23:14:04 1994 Jim Meyering (meyering@comco.com) * tail.c (tail_file): Fix call to error with %s in format, but no corresponding argument. * src/*.c: Include "error.h" instead of simply declaring `void error ();'. * od.c (main): Use %lu, not %d for unsigned long. (my_strtoul, uint_fatal_error): Remove functions. Use xstrtoul and STRTOL_FATAL_ERROR instead. Sun Dec 11 17:24:09 1994 Jim Meyering (meyering@comco.com) * sort.c (main): Fix interpretation of field offsets when specified via -k option. They were being interpreted as zero-indexed. POSIX says they are 1-based indices. From Rik Faith . (keycompare): Don't ignore characters at the end of words when otherwise they would compare equal. From Rik Faith. * tail.c (): Change the type of n_units/n_lines/n_bytes to off_t because n_bytes is used as the option to fseek and off_t may be long long (e.g. on BSD4.4). The only place where a 32-bit limit is imposed is in the string-to-integer converstion of xstrtol. (main): Use xstrtol instead of manual string to integer conversion. * csplit.c (get_format_width, get_format_prec): Use ISDIGIT instead of comparisons against '0' and '9'. * tr.c [!ULONGMAX]: Define it. [!LONGMAX]: Define in terms of ULONGMAX instead of as a 32-bit constant. * full-write.c: Declare (or not) errno based on definedness or errno, not STDC_HEADERS. * safe-read.c: Likewise. * xwrite.c: Likewise. Thu Nov 17 06:37:33 1994 Jim Meyering (meyering@comco.com) * tail.c (dump_remainder): Flush standard output just before sleeping so that `tail -f' will output partial lines sooner. This applies only when following the end of a single file. From Leonard N. Zubkoff . * tail.c (file_lines, pipe_lines, pipe_bytes, start_bytes, start_lines, dump_remainder): Use STDOUT_FILENO instead of `1' in XWRITE calls. * tac.c (output): Use STDOUT_FILENO instead of `1' in xwrite call. * system.h (STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO): Define if not already defined. Wed Nov 16 07:01:38 1994 Jim Meyering (meyering@comco.com) * tr.c: Include instead of "getopt.h". * sort.c (tempname): Merge two very similar sprintf stmts into one. * tail.c: Use BUFSIZ instead of BUFSIZE. * cut.c: Declare DELIM to be `int' rather than unsigned char. * fmt.c: Use index, not strchr -- per GNU Standards. Reported by Kaveh Ghazi. Always include . (main): Include program name in --version output. Sun Nov 06 00:17:21 1994 Jim Meyering (meyering@comco.com) * Version 1.11. Sat Nov 05 15:14:44 1994 Jim Meyering (meyering@comco.com) * memcmp.c, srtoul.c: Use up-to-date versions. Reported by Franc,ois Pinard. * src/Makefile.in (DEFS): Remove -Dlint... again. * src/Makefile.in (PROGS): Add fmt! Reported by Andreas Stolcke (stolcke@ICSI.Berkeley.EDU). Fri Nov 04 17:26:16 1994 Jim Meyering (meyering@comco.com) * Version 1.10. Thu Nov 03 23:23:08 1994 Jim Meyering (meyering@comco.com) * linebuffer.h: Use __P instead of _P since the latter conflicts with a definition in some . From Kaveh Ghazi. Wed Nov 02 17:36:34 1994 Jim Meyering (meyering@comco.com) * tr.c: Add const attribute where appropriate. * tail.c (BUFSIZ): Use definition from . Tue Nov 01 23:54:09 1994 Jim Meyering (meyering@comco.com) * tail.c (XWRITE): Allow n_bytes == 0 but call fwrite only if n_bytes is positive. Turn off assertions. `tail /dev/null' was getting a failed assertion. Reported by Doug McLaren (dougmc@comco.com). * cut.c (cut_bytes): Print at least a newline for every line of input. (cut_fields): Print a newline even for lines whose only selected field is empty. But print nothing when using -s without -f1. And print nothing for empty input. Reported by Richard_Sharman@software.mitel.com. Tue Nov 01 06:05:23 1994 Jim Meyering (meyering@comco.com) * fmt.c: Change #ifdef __STDC__ to #if defined (__STDC__) && __STDC__. * linebuffer.h: Likewise. Mon Oct 31 06:53:32 1994 Jim Meyering (meyering@comco.com) * configure.in (AC_REPLACE_FUNCS): Remove memcmp since AC_FUNC_MEMCMP already handles it. From Kaveh Ghazi. * {lib,src}/Makefile.in (DEFS): Don't use -Dlint. Some systems get failures when it's defined. From Kaveh Ghazi. * cat.c (cat): Conditionalize test for errno == ENOSYS. It's not defined on some Next and Alliant systems. From Kaveh Ghazi. * sort.c join.c (main): Include version.h and call parse_long_options with the proper number of arguments. Reported by Franc,ois Pinard. Sun Oct 30 01:30:41 1994 Jim Meyering (meyering@comco.com) * (configure.in): Add AC_OFF_T and rearrange by type along the same lines as autoscan. * fmt.c, fmt.1: New files. Both from Ross Paterson (rap@doc.ic.ac.uk). * Makefile.in (PROGS): Add fmt. * src/Makefile.in (SOURCES, OBJECTS): Add fmt.c and fmt.o respectively. (fmt): Add a link rule. * man/Makefile.in (MANFILES): Add fmt.1. Sat Oct 08 10:44:30 1994 Jim Meyering (meyering@comco.com) * Makefile.in (All of them): Update from the ones in sh-utils. From now on, rules and definitions that are comon to the fileutils, textutils, and sh-utils will get ChangeLog entries only in the sh-utils. Tue Oct 04 20:42:46 1994 Jim Meyering (meyering@comco.com) * od.c (my_strtoul): Set errno to zero before calling strtoul. Otherwise, od can fail complaining about a valid integer argument. From Andreas Schwab. Sun Oct 02 17:57:09 1994 Jim Meyering (meyering@comco.com) * tr.c (main): Give an error and fail when squeezing repeats and no non-options are given. Reported by Tony Robinson (ajr@eng.cam.ac.uk). * sort.c (main): Temporarily copy each input file that might be another name for the output file. When in doubt (e.g. a pipe), copy. This allows the dangerous (historical -- in cnews) idiom `cat file | sort -o file' to work properly. Don't rely on this behavior in new shell scripts. From Paul Eggert (eggert@twinsun.com). Mon Sep 26 18:01:47 1994 David J. MacKenzie (djm@churchy.gnu.ai.mit.edu) * lib/xwrite.c safe-read.c memchr.c linebuffer.c full-write.c: Remove CONFIG_BROKETS ifdef. * src/Makefile.in lib/Makefile.in: Don't define it. Sat Sep 24 21:26:27 1994 Jim Meyering (meyering@comco.com) * full-write.c (full_write): Declare argument LEN to be size_t. Mon Sep 12 13:35:27 1994 Jim Meyering (meyering@comco.com) * tail.c (tail_file): [For multiple files only]: Report truncation of monitored file and reset current file size. From Franc,ois Pinard. Sat Aug 27 16:57:20 1994 Jim Meyering (meyering@comco.com) * system.h [BROKEN_STAT_MACROS]: Remove unnecessary #ifdef's. From Franc,ois Pinard. Tue Jul 26 11:33:53 1994 Jim Meyering (meyering@comco.com) * system.h: Remove `|| defined(_POSIX_VERSION)' from test that decides whether to include . From Francois Pinard. Wed Jul 13 12:33:34 1994 Jim Meyering (meyering@comco.com) * tr.c (substr): Fix off-by-one allocation error. Wed Jun 22 01:02:50 1994 Jim Meyering (meyering@comco.com) * tac.c (tac_file): Use O_RDONLY instead of zero in call to open. (tac): Fix typo that had `1' as arg #2 of error after failed read. Use errno instead. From Michael I Bushnell . Thu May 26 08:46:32 1994 Jim Meyering (meyering@comco.com) * configure.in [INSTALL]: Revert change of March 25. autoconf has been fixed. Mon Apr 11 17:25:43 1994 Jim Meyering (meyering@comco.com) * join.c (prline): Remove unused function. Indent. Fri May 6 05:44:24 1994 Jim Meyering (meyering@comco.com) * tail.c (tail_forever): Don't print headers when asked not to. From Karsten Thygesen . * wc.c (wc): Optimize for the case when only bytes are being counted and the input is not a regular file. From Jeff Moore . Sun Apr 24 10:54:08 1994 Jim Meyering (meyering@comco.com) * configure.in [AC_SIZEOF_TYPE]: Update for autoconf-1.9. * memchr.c: Test SIZEOF_LONG instead of LONG_64_BITS. Mon Apr 11 17:55:52 1994 Jim Meyering (meyering@comco.com) * csplit.c (struct control): Add new field, repeat_forever. Remove now-unneeded definition of INT_MAX. (process_regexp): Test repeat_forever instead of comparing `repeat' to INT_MAX. (split_file): Don't even reference `repeat' count if repeat_forever is set. (new_control_record): Initialize repeat_forever field. (parse_repeat_count): Set it instead of setting repeat count to INT_MAX. (process_line_count): Abort for internal error instead of calling handle_line_error. * long-options.c (parse_long_options): Take a new argument indicating the utility name (e.g. "join", not "gjoin") for version output. Print both the utility and the package names, e.g. `join - GNU textutils-1.9.1' instead of just the package name. * join.c (main): Call parse_long_options with program name arg. * sort.c (main): Ditto. * All source except sort.c and join.c (main): Change --version output to include utility name as well as package name and version info. 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@. Mon Mar 28 09:55:05 1994 Jim Meyering (meyering@comco.com) * tr.c (main): In addition to the --help usage pointer, give an explicit error message for too many arguments. Fri Mar 25 18:11:19 1994 Jim Meyering (meyering@comco.com) * configure.in: Use AC_VERBOSE, AC_CHECKING, and AC_WARN instead of explicit echo commands. [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. [AC_SIZEOF_TYPE]: Use this instead of deprecated AC_LONG_64_BITS. * cat.c (cat): The command `:|cat -s' failed on Irix5 because ioctl (d, FIONREAD,... now returns ENOSYS for pipes -- under Irix4 it returned EINVAL. Detect this. (main) [lint]: Initialize variables to suppress `used before initialized' warnings. * csplit.c: Change long option name from --suffix to --suffix-format. * od.c (skip): Correct a comment. (main): Don't output anything to stdout if the sole input file doesn't exist. Reported by Bauke Jan Douma . * od.c (dump) [lint]: Initialize a variable to suppress `used before initialized' warning. (main) [lint]: Ditto. * paste.c (paste_parallel) [lint]: Ditto. 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 18 16:14:00 1994 Jim Meyering (meyering@comco.com) * unexpand.c (unexpand): Don't segfault when given a name of a nonexistent file. * expand.c (expand): Ditto. Both from Bauke Jan Douma . 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). * csplit.c (load_buffer): Rather than incrementing buffer size, double it each time we fail to find a newline. Otherwise, csplit would run out of memory when processing files with very long lines. Mon Jan 10 01:20:38 1994 Jim Meyering (meyering@comco.com) * man/Makefile.in (manprefix): Use binprefix as the default. Sat Jan 08 22:22:45 1994 Jim Meyering (meyering@comco.com) * cat.c: Use full_write and safe_read instead of write and read resp. * csplit.c: Ditto. * head.c: Ditto. * split.c: Ditto. * tac.c: Ditto. * sum.c: Use safe_read instead of read. * tr.c: Ditto. * wc.c: Ditto. * tail.c: Replace calls to xwrite with calls to fwrite. Use fopen/fclose instead of open/close. (write_header): Use a single call to printf instead of four to xwrite. Use safe_read instead of read. * head.c: Ditto. Tue Dec 28 15:49:32 1993 Jim Meyering (meyering@comco.com) * install.sh: New file. Makefile.in [DISTFILES]: Add it. Wed Dec 22 18:52:44 1993 Jim Meyering (meyering@comco.com) * memcmp.c: Use the latest version from the GNU C library. * cut.c [ADD_RANGE_PAIR]: New macro. (set_fields): Collect the list of all selected ranges before allocating and initializing the boolean lookup table. (cut_bytes, cut_fields): Complete rewrite. Avoid copying into buffer whenever possible. Properly handle input without trailing newline. (getstr): New function. Copied from getline.c, but with minor changes. * sort.c (main): Properly handle -Tdir. Before, `sort -T/var/tmp' gave `sort: unrecognized option `-v''. Reported by Kristoffer Rose (kris@diku.dk). * cut.c (main): Give separate errors for `-s without -f' and `-d without -f'. (main): Now -d '' means `use the NUL byte as the delimiter'. Before, it got an error. 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. Thu Dec 02 23:53:03 1993 Jim Meyering (meyering@comco.com) * configure.in (AC_HAVE_FUNCS): Add isascii. * system.h [!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). Fri Nov 19 22:41:48 1993 Jim Meyering (meyering@comco.com) * configure.in: Don't run the test for 8-bit clean memcmp if we already know we'll be using our replacement. Fri Nov 12 00:44:49 1993 Jim Meyering (meyering@comco.com) * Version 1.9.1. * tac.c (usage): Fix typo in long usage. * sort.c (usage): Likewise. From Philippe.Schnoebelen@imag.fr. * cut.c [FATAL_ERROR]: New macro. (main): Call both error and usage (2) through FATAL_ERROR in many places. Before, only `error (2...' was called. (invalid_list): Removed. This function is subsumed by FATAL_ERROR. * cut.c (cut_fields): Properly handle input lacking a terminating newline. Before, the command `printf "a\tb" |cut -f 1' generated no output. Tue Nov 09 17:26:25 1993 Jim Meyering (meyering@comco.com) od.c (usage): Change --backward-compatible to --traditional in the long usage message. Sun Nov 07 00:50:05 1993 Jim Meyering (meyering@comco.com) * Version 1.9. Sat Nov 06 22:51:31 1993 Jim Meyering (meyering@comco.com) * cut.c (cut_fields): Revert July 27 change. Instead, strip off trailing delimiter unless given a range of fields like `3-' that extends to end of line. (set_fields): Moved local `eol_range_start' to file-scope. Reported by Arne H. Juul (arnej@solan.unit.no). Tue Nov 02 00:53:41 1993 Jim Meyering (meyering@comco.com) * fold.c (fold_file): Don't get stuck in an endless loop when width is smaller than 8 and there are TABs in the input. Sat Oct 30 15:31:28 1993 Jim Meyering (meyering@comco.com) * join.c: Remove now-unused dcls of show_help and show_version. Fri Oct 29 13:58:50 1993 Jim Meyering (meyering@comco.com) * csplit.c [INT_MAX]: Make sure it's defined. [not HAVE_LIMITS_H]: Don't include limits.h. From Kaveh R. Ghazi (ghazi@noc.rutgers.edu). Wed Oct 27 01:13:52 1993 Jim Meyering (meyering@comco.com) * Version 1.8.1. Mon Oct 25 20:16:33 1993 Jim Meyering (meyering@comco.com) * sort.c: Accept but ignore -y0 for compatibility with Solaris 2. From Chuck Hedrick (hedrick@klinzhai.rutgers.edu). * sort.c (main): Handle --help and --version options. * Makefile.in (sort.o): Depend on long-options.h. Sun Oct 24 00:31:02 1993 Jim Meyering (meyering@comco.com) * csplit.c, cut.c, expand.c, fold.c, head.c, nl.c, od.c, paste.c, split.c, tac.c, tail.c, unexpand.c, uniq.c: Use the preferred `--longopt=arg' syntax in --help message rather than `--longopt arg'. From Francois Pinard. * tail.c: Don't include . It hasn't been necessary since the Dec 12, 1992 change. * join.c (main): Accept `-v 1' again. Adding the --version long option had broken it, although -v1 still worked. Call parse_long_options instead of adding "help" and "version" to join's longopt strct. * Makefile.in [SOURCES, OBJECTS, DISTFILES]: Add long-options.c and long-options.h. * (join): Depend on and link with long-options.o. * (join.o): Depend on long-options.h. * od.c: Change --compatible (-C) to --backward-compatible (-B). * csplit.c: Change --abandon-null-files to --elide-empty-files. Sat Oct 23 01:00:12 1993 Jim Meyering (meyering@comco.com) * tr.c (get_next, string2_extend): Add default: label to switch stmt. * cat.c, cksum.c, comm.c, csplit.c, cut.c, expand.c, fold.c, head.c, join.c, nl.c, od.c, paste.c, pr.c, split.c, sum.c, tac.c, tail.c, tr.c, unexpand.c, uniq.c, wc.c (usage): Add long --help. Exit successfully for --help, non-zero for usage error. From Francois Pinard. * configure.in: Add AC_STAT_MACROS_BROKEN. * system.h [AC_STAT_MACROS_BROKEN]: Test it. Fri Oct 22 23:26:17 1993 Jim Meyering (meyering@comco.com) * linebuffer.c, memchr.c [HAVE_CONFIG_H, CONFIG_BROKETS]: Include or "config.h". * cat.c, cksum.c, comm.c, csplit.c, cut.c, expand.c, fold.c, head.c, join.c, nl.c, od.c, paste.c, pr.c, sort.c, split.c, sum.c, tac.c, tail.c, tr.c, unexpand.c, uniq.c, version.c, wc.c: Ditto. * configure.in: Use AC_CONFIG_HEADER. * Makefile.in [DIST]: Add config.h.in. * Makefile.in: Convert so make may be run from subdirectories. Add dependencies on config.h. * src/Makefile.in: Ditto. * lib/Makefile.in: Ditto. * man/Makefile.in: Ditto. Wed Oct 20 20:05:48 1993 Jim Meyering (meyering@comco.com) * memchr.c (memchr): Do the 32-bit assignment only if !LONG_64_BITS. In the 64-bit assignment, be careful to cast the shift operand to long. Abort if sizeof (unsigned long) > 8. Tue Oct 19 22:37:58 1993 Jim Meyering (meyering@comco.com) * csplit.c: Allow repeat counts to be specified via `{*}'. New option --suffix=format. Supercedes --digits option. New option --abandon-null-files. From Ronald F. Guilmette (rfg@netcom.com). * csplit.1: Updated. From Ronald F. Guilmette. * csplit.c: Remove register keyword (replace with `int' in two cases). * csplit.c: [MAX]: Macro renamed from max and moved to top of file. (bytes_to_octal_digits): New static array. (get_format_flags): Combine '+' and ' ' cases of switch stmt. Return count if for loop terminates. (get_format_width): Use `bytes_to_octal_digits' instead of just 11. (get_format_prec): Make sure is_negative is defined before used. (get_format_conv_type): Give a different error message if there is no conversion specifier. Test ISPRINT (ch) instead of `ch < '~' && ch > ' ''. (max_out): Use `%%' rather than `%' in format string. Sat Oct 16 10:45:17 1993 Jim Meyering (meyering@comco.com) * pr.c (main): When argc == 1, don't try to xmalloc (0). Tue Oct 12 00:53:26 1993 Jim Meyering (meyering@comco.com) * xwrite.c [HAVE_CONFIG_H, CONFIG_BROKETS]: Include or "config.h". Sat Oct 09 23:37:43 1993 Jim Meyering (meyering@comco.com) * configure.in: Remove AC_UNISTD_H; add unistd.h to AC_HAVE_HEADERS. Thu Sep 9 21:52:10 1993 Jim Meyering (meyering@comco.com) * src/*.c: Print version on standard output, not stderr. * configure.in: Add AC_LONG_64_BITS. * memchr.c: Use #ifdef LONG_64_BITS instead of `if (sizeof(longword) > 4)'. Tue Jul 27 22:19:39 1993 Jim Meyering (meyering@comco.com) * cat.c (cat): Don't fail just because ioctl (d, FIONREAD,... can't always handle devices. Ignore errno == EINVAL and errno == ENODEV. `cat -v /dev/null' was failing on many systems. * cut.c (cut_fields): Don't strip off trailing delimiter e.g. `echo 'a:b:c:' | cut -d: -f3-' should print `c:', not just `c'. From William Dowling . Thu May 27 01:37:51 1993 Jim Meyering (meyering@comco.com) * Version 1.8. * memchr.c: De-ansify the fixed version from glibc. It is supposed to work on systems with 64-bit long ints. Mon May 24 00:32:43 1993 Jim Meyering (meyering@comco.com) * Version 1.7. Sat May 22 02:13:12 1993 Jim Meyering (meyering@comco.com) * Version 1.6. Fri May 21 22:57:53 1993 Jim Meyering (meyering@comco.com) * pr.c (cols_ready_to_print): New function. It replaces a global variable by the same name and computes on the fly the value that was supposed to be maintained through that variable. This should put to rest the `pr -2a' bug. (main): Don't let getopt_long reorder arguments so we can distinguish between `pr -1 -2' and `pr -12'. Rework handling of -n and +n options. * fold.c: Declare xmalloc. Wed May 19 19:12:18 1993 Karl Berry (karl@owl.hq.ileaf.com) * sort.c (main): fflush before exit, so a closed stdout doesn't lose. Tue May 18 23:49:26 1993 Jim Meyering (meyering@comco.com) * mkinstalldirs: New file. * Makefile.in (installdirs): Use it to create installation directories. Fri May 14 23:45:52 1993 Jim Meyering (meyering@comco.com) * all source: With --version, print version and exit immediately. 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. * tail.c (main): Remove --compatible since `+1f' may be used to get the BSD `-0f' behavior portably. * fold.c (main): Turn -N arguments, where N is a digit, into -wN. From Ian Lance Taylor (ian@cygnus.com). Mon May 10 22:33:44 1993 Jim Meyering (meyering@comco.com) * tail.c (main): New option -C, --compatible to make `tail -0f' work like `tail +1f' for compatibility with BSD tail. Thu May 6 23:28:56 1993 Jim Meyering (meyering@comco.com) * pr.c (print_page): Decrement cols_ready_to_print even when lines_to_print == 0. The command `echo |pr -2ta' *still* didn't terminate. Add parentheses for clarity. Mon May 3 23:57:47 1993 Jim Meyering (meyering@comco.com) * Version 1.5. * od.c (main): Remove set-but-not-used variable, `usage_error'. * split.c (main): Call usage with an argument. Sun May 2 16:05:04 1993 Jim Meyering (meyering@comco.com) * configure.in: Reverse if-else branches in AC_TEST_PROGRAM test for 8-bit clean memcmp. * cat.c (usage, main): Remove unused argument. * csplit.c (remove_line): Remove set-but-not-used variable, `line_got.' (check_for_offset): Remove unused argument `argnum.' * configure.in: Add AC_SIZE_T. Sat May 1 09:03:19 1993 Jim Meyering (meyering@comco.com) * uniq.c (main): Interpret non-option arguments with a leading `+' only if we haven't seen `--'. * tr.c (main): Change variable name to avoid shadowed dcl. * wc.c (write_counts): Ditto. * sum.1: Make documentation agree with the code. * od.c: Depend only on HAVE_LONG_DOUBLE for long double support. Fri Apr 30 20:16:03 1993 Jim Meyering (meyering@comco.com) * configure.in [AC_HAVE_HEADERS]: Add limits.h. * configure.in [CFLAGS, LDFLAGS]: Assign reasonable defaults. * od.c (parse_old_offset): Don't use prototype in function definition. Remove unnecessary conjunct from test for hexadecimal prefix. * od.c: Depend on __GNUC__ || HAVE_LONG_DOUBLE rather than __STDC__ for long double support; there are compilers (Stardent Vistra svr4) without long double but still define __STDC__. Thu Apr 29 02:01:27 1993 Jim Meyering (meyering@comco.com) * src/*.c and man/*.c except for sort: Add --help and --version options. * pr.c: Convert to use getopt_long. * lib/memcmp.c: Use version from glibc. [WORDS_BIGENDIAN]: Test this instead of the using glibc's __BYTE_ORDER macro. * configure.in: Use AC_WORDS_BIGENDIAN to set it. * od.c (parse_old_offset): Allow `0X' as well as `0x' prefix to indicate hex. * Makefile.in (dist): Depend on Makefile so that changes to Makefile.in (like adding new files to DISTRIB) are reflected in the new distribution. Fri Apr 23 21:53:47 1993 Jim Meyering (meyering@comco.com) * {lib,src}/Makefile.in [.c.o]: Make CPPFLAGS and CFLAGS follow other options so users can use them to override DEFS. * src/Makefile.in [.c.o]: Add -I$(srcdir) for version.h. * Makefile.in [CFLAGS, LDFLAGS]: Don't set to -g explicitely; configure's AC_SUBST will set these. * Makefile.in [Makefile]: Add dependencies and a rule to remake it. [targets that cd then run make in subdirectories]: Don't depend on `cd ..'; use a subshell instead. * Makefile.in [info, install-info, dvi, check, installcheck]: New targets but no rules; comply with standards. * configure.in [CFLAGS]: Default to -g -O if CC is gcc and the user hasn't specified CFLAGS. [LDFLAGS]: Substitute into Makefile. Tue Mar 30 21:36:11 1993 Jim Meyering (meyering@comco.com) * od.c: New option --compatible, -C. (parse_old_offset): New function. * od.1: Document new option. Mon Mar 29 21:27:56 1993 Jim Meyering (meyering@comco.com) * cut.c, expand.c, join.c, nl.c: Always call error with errno (not zero) after failed fclose or non-zero ferror. Sun Mar 28 16:59:31 1993 Mike Haertel (mike@cs.uoregon.edu) * configure.in: Add check for working memcmp; use GNU's if the system's doesn't grok the 8th bit. * memcmp.c: Fix it so it groks the 8th bit. TODO: We really need to provide a fast memcmp, since most machines will have a broken memcmp. Probably should get the one from glibc. * sort.c (mergefps): Maintain keybeg and keylim when copying the current line to `saved'. (numcompare): Skip white space here since -n no longer implies -b. (getmonth): Skip white space here since -M no longer implies -b. (compare): Completely overhauled to make the 8th bit work right, also to properly handle the global reverse option. (set_ordering): -n no longer implies -b, according to Posix. For consistency, -M also no longer implies -b. (main): Correct treatment of -r and global keys. (findlines): Clear keybeg and keylim if no keys are used. (sort): Avoid overwriting tempfiles[] array bounds. Sun Mar 21 22:29:29 1993 Jim Meyering (meyering@comco.com) * pr.c (close_file): Reverse May 13, '92 change, but add the condition that cols_ready_to_print not be decremented when printing across. The command `echo |pr -2ta' didn't terminate. (print_page): Rewrite conditional (that had side effects in second conjunct) using nested if statements to make it clear that we do indeed want those semantics. Tue Jan 19 13:35:24 1993 David J. MacKenzie (djm@kropotkin.gnu.ai.mit.edu) * Version 1.4. * system.h: Try BBSIZE if BSIZE isn't defined. From Tony Robinson . Sat Dec 12 12:37:00 1992 David J. MacKenzie (djm@kropotkin.gnu.ai.mit.edu) * tail.c (tail_forever): Use an array of file descriptors instead of forking processes. (dump_remainder): Return number of bytes read. (tail_file): Fill in the new array. From Ian Lance Taylor. Fri Dec 11 17:18:16 1992 David J. MacKenzie (djm@kropotkin.gnu.ai.mit.edu) * system.h: Only define index, bcmp, etc. if not already defined. Tue Dec 8 10:31:14 1992 Jim Meyering (meyering@idefix.comco.com) * tr.c (is_char_class_member): Remove unreached return after abort. Sun Dec 6 22:34:52 1992 Jim Meyering (meyering@idefix.comco.com) * csplit, cut.c, expand.c, fold.c, head.c, join.c, od.c, pr.c, sort.c, split.c, tail.c, tr.c, unexpand.c, uniq.c: Remove inclusion of and definitions of is* ctype macros to system.h. Change a few more uses of is* ctype macros to (protected) upper case versions. * system.h: Add isascii-protected ctype IS* macros. Wed Dec 2 12:28:10 1992 Jim Meyering (meyering@idefix.comco.com) * all files using getopt.h: Convert static declarations of struct option to use new macros from getopt.h: no_argument, required_argument, and optional_argument. Tue Dec 01 10:57:24 1992 Jim Meyering (meyering@idefix.comco.com) * od.c, pr.c, sort.c: Make uses of ctype.h macros consistent. * tr.c (main): Close stdin and stdout and check return status. Tue Nov 24 09:26:08 1992 David J. MacKenzie (djm@goldman.gnu.ai.mit.edu) * system.h, csplit.c: Use HAVE_FCNTL_H and HAVE_STRING_H instead of USG. Tue Nov 24 08:42:30 1992 Jim Meyering (meyering@idefix.comco.com) * tr.c: Define new macros ISPRINT, ISALNUM, ISXDIGIT, ... that use isascii if it is defined. (is_char_class_member, make_printable_char, make_printable_str, non_neg_strtol): Use new macros instead of lower case ones from . * od.c (print_ascii, dump_strings): Use ISDIGIT and ISPRINT macros like pr.c. Suggested by David J. MacKenzie. * od.c (print_ascii, dump_strings): Check for isascii before isprint. (dump_strings): Free malloc'd buffer before returning. (skip): Return non-zero if an error occurred, zero otherwise. Exit only if asked to skip beyond end of combined input. (check_and_close): New function. (skip, read_block, read_char): Call check_and_close when done processing the file associated with in_stream. (skip, read_block, read_char): Set have_read_stdin. (main): Close stdin (if it was ever read) and check for errors just before exiting. (write_block, dump_strings, dump): Don't test return value from functions that operate on streams. Rely on later ferror tests. Sat Nov 21 12:41:49 1992 David J. MacKenzie (djm@goldman.gnu.ai.mit.edu) * sort.c (main, usage): Add -T option. Thu Nov 19 14:33:40 1992 David J. MacKenzie (djm@goldman.gnu.ai.mit.edu) * tail.c (tail_forever, sigusr1, kill_kids): New functions to do -f on multiple files. (main): Call tail_forever. From Ian Lance Taylor. Tue Nov 10 14:29:11 1992 David J. MacKenzie (djm@goldman.gnu.ai.mit.edu) * cut.c (cut_fields): Add cast. * od.c (decode_one_format): Remove '#' from pre_fmt_string; many systems don't support it. Conditionalize long double support on __STDC__, not __GNUC__. From Ian Lance Taylor. Mon Nov 9 00:24:41 1992 Jim Meyering (meyering@idefix.comco.com) * sort.c (numcompare, keycompare): Add parentheses suggested by gcc -Wall. Put braces around individual monthtab initializers. * cksum.c: Declare error. Make checksum table `const.' * pr.c: Remove comment and dcl of unused variable, `print_a_number'. * split.c (main): Add `default: abort();' to enumeration switch. * All files: Make all functions and extern variables static. Make all longopts arrays const as well as static. Make a couple statically initialized aggregates `const.' Sun Nov 8 19:46:59 1992 David J. MacKenzie (djm@goldman.gnu.ai.mit.edu) * od.c (main): Make old-style format options accumulate. From Jim Meyering. Sat Nov 7 00:26:14 1992 David J. MacKenzie (djm@goldman.gnu.ai.mit.edu) * tr.c (look_up_char_class): Add cast. * nl.c (build_type_arg), csplit.c (extract_regexp), tac.c (main): Add `const' to variable receiving value from re_compile_pattern. * wc.c (wc): If doing only -c, use st_size for regular files. * fold.c (fold_file): Was folding 1 column too early. From Eric Backus . * memset.c: New file. Fri Nov 6 20:14:51 1992 David J. MacKenzie (djm@goldman.gnu.ai.mit.edu) * cksum.c: New file. Tue Oct 13 16:24:06 1992 David J. MacKenzie (djm@goldman.gnu.ai.mit.edu) * tac.c (tac_stdin): Handle SIGPIPE. * sort.c (main): Handle SIGTERM. * od.c: New file. * system.h [USG || STDC_HEADERS]: Define bcmp. Sat Oct 3 20:41:24 1992 David J. MacKenzie (djm@goldman.gnu.ai.mit.edu) * sort.c (main): Handle SIGPIPE. From trq@dionysos.thphys.ox.ac.uk. Tue Sep 29 01:10:05 1992 David J. MacKenzie (djm@nutrimat.gnu.ai.mit.edu) * paste.c (main): Don't write on a string constant. Mon Aug 24 00:02:45 1992 Jim Meyering (meyering@churchy.gnu.ai.mit.edu) * tr.c: Minor cleanup. Replaced some assert(0) with abort(). Tue Jul 7 02:14:19 1992 David J. MacKenzie (djm@nutrimat.gnu.ai.mit.edu) * cmp.c, cmp.1: Move to diff distribution. Fri Jul 3 16:37:59 1992 David J. MacKenzie (djm@nutrimat.gnu.ai.mit.edu) * system.h: Change FOO_MISSING to HAVE_FOO. Wed May 13 20:05:41 1992 David J. MacKenzie (djm@churchy.gnu.ai.mit.edu) * pr.c (COLUMN): Add structure member to remember filename. (main, init_fps, open_file, close_file): Use it. (close_file): Don't decrement cols_ready_to_print when closing a file. From cdl@mpl.UCSD.EDU (Carl Lowenstein). Mon May 11 19:17:33 1992 David J. MacKenzie (djm@churchy.gnu.ai.mit.edu) * cmp.c: --show-chars -> --print-chars. * pr.c: Rename some variables. Sat May 9 18:39:47 1992 David J. MacKenzie (djm@wookumz.gnu.ai.mit.edu) * system.h: Define DEV_BSIZE if not defined. Wed Apr 22 02:15:09 1992 David J. MacKenzie (djm@churchy.gnu.ai.mit.edu) * system.h, tac.c: SIGTYPE -> RETSIGTYPE. Fri Apr 17 10:42:23 1992 David J. MacKenzie (djm@wookumz.gnu.ai.mit.edu) * sort.c (main): Don't stop processing args when we hit "-"; treat it like a regular filename. From ian@airs.com (Ian Lance Taylor). * pr.c (print_page): Fix off by one line count when ^L is in input. From Andreas Schwab (schwab@ls5.informatik.uni-dortmund.de). Mon Apr 6 20:52:29 1992 Jim Meyering (meyering@churchy.gnu.ai.mit.edu) * tr.c (validate): Change error message so it doesn't mention actual name of --truncate-set1 option. From David MacKenzie. Sun Apr 5 14:22:42 1992 Jim Meyering (meyering@hal.gnu.ai.mit.edu) * tr.c (string2_extend, validate): Give an error message when translating without --truncate-set1, with empty string2, and with non-empty string1. "tr 1 ''" produced a failed assertion. Mon Mar 30 02:20:56 1992 David J. MacKenzie (djm@wookumz.gnu.ai.mit.edu) * system.h: Change how ST_BLKSIZE is calculated to allow for non-POSIX systems that don't define BSIZE in sys/param.h. Sat Mar 28 11:18:01 1992 David J. MacKenzie (djm@wookumz.gnu.ai.mit.edu) * sum.c (main, bsd_sum_file): Don't print filename if BSD algorithm is used and only one file was given. Wed Mar 25 11:34:41 1992 Jim Meyering (meyering@wombat.gnu.ai.mit.edu) * tr.c (get_spec_stats): Fix assertion to allow ranges like a-a with starting character equal to ending character. This is contrary to the POSIX spec, but what is already implemented in find_closing_delim. Mon Mar 16 00:15:11 1992 David J. MacKenzie (djm@wookumz.gnu.ai.mit.edu) * Version 1.3. * sort.c (numcompare, checkfp): Add parens to placate gcc2. * sort.c (mergefps): For -u, output the first, not last, of the lines that compare equal. From Mike Haertel. Tue Mar 10 10:51:38 1992 David J. MacKenzie (djm@nutrimat.gnu.ai.mit.edu) * tr.c: Remove initial capitals and periods from error messages. Sun Mar 8 22:03:45 1992 David J. MacKenzie (djm@nutrimat.gnu.ai.mit.edu) * sum.c (main): Add -r option for SYSV compat. Thu Feb 27 22:26:25 1992 David J. MacKenzie (djm@wookumz.gnu.ai.mit.edu) * sort.c (compare): If -s given, leave lines in their original order. (main): Recognize -s. (usage): Document -s. From Mike Haertel. Tue Feb 18 20:29:45 1992 Randall Smith (randy at geech.gnu.ai.mit.edu) * sort.c (sort): Check for complete parsing of buffer into lines before nixing temp files. Mon Feb 17 10:35:58 1992 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * sum.c (sysv_sum_file): Use %lu instead of %u to print a long. Not that it matters for GNU . . . * tr.c (unquote, make_printable_str): Use \007 instead of ANSI \a. (append_normal_char, append_range, append_char_class, append_repeated_char, append_equiv_class, spec_init): Initialize `next' field of new `struct List_element'. From rommel@informatik.tu-muenchen.de (Kai-Uwe Rommel). Sat Feb 8 17:16:49 1992 David J. MacKenzie (djm at apple-gunkies.gnu.ai.mit.edu) * join.c (get_line): Renamed from getline to avoid GNU libc conflict. Sun Feb 2 21:22:01 1992 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * Version 1.2. * nl.c: Support multiple files and "-" for stdin. (main): Check for read and write errors. (nl_file): New function. Wed Jan 29 10:09:10 1992 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * tr.c (main): -t option was called -b in getopt spec. (validate): Don't warn that set1 is longer than set2. * tr.c: Rename --sysv-string2-truncate to --truncate-string1. Fri Jan 17 16:29:05 1992 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * nl.c: New program from bin-src. * nl.c (main): Use a struct linebuffer for line_buf. (process_file): Use readline instead of fgets, to preserve NULs. (check_section): Use memcmp instead of strncmp. (proc_text): Print line_buf with fwrite instead of printf. * nl.c (main): Usage message if too many args given. Check for error in closing input file. Lengths of section delimiter strings were 1 too large. Take separator_str into account in length of print_no_line_fmt. (build_print_fmt): Allocate space for print_fmt, in case separator_str is long. (proc_text): A blank line is one that contains nothing, not even nonprinting characters. Fri Jan 17 01:04:22 1992 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * All programs: Document `--' instead of `+' to introduce long-named options, in usage messages. * sum.c (bsd_sum_file): Renamed from sum_file. (sysv_sum_file): New function. (main): Recognize an option to select between the algorithms. Sun Jan 5 17:41:18 1992 Jim Meyering (meyering at churchy.gnu.ai.mit.edu) * pr.c (close_file, print_page): Fixed bug that had the command yes |head |pr -t printing "yyyyyyyyyy". * (print_page): Fixed bug that had pr -3 -a printing two too few trailer lines per page. * (main): Added restriction that -a and -m are incompatible. Although the POSIX spec doesn't explicitly say they shouldn't be used together, it says -a modifies the -column option and that -column shouldn't be used with -m. Thu Jan 2 15:23:59 1992 David J. MacKenzie (djm at albert.gnu.ai.mit.edu) * nl.c: Include regex.h after, not before, sys/types.h. Thu Jan 2 12:18:10 1992 Tom Lord (lord at geech.gnu.ai.mit.edu) * sort.c (fillbuf) return bytes buffered instead of bytes read. Fri Dec 27 22:53:36 1991 Jim Kingdon (kingdon at geech.gnu.ai.mit.edu) * sort.c (LINEALLOC): New #define. (struct lines): New field ``limit''. (initlines): Set it from new arg ``limit''. (sort, mergefps, checkfp): Pass new arg to initlines(). (findlines): Don't realloc past lines->limit. Tue Dec 24 01:24:03 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * tac.c, sort.c, csplit.c, system.h: Change POSIX ifdefs to HAVE_UNISTD_H and _POSIX_VERSION. * xwrite.c: Change POSIX ifdef to HAVE_UNISTD_H. Sat 14 Dec 1991 11:46:42 Jim Meyering (meyering at wombat) * tr.c: Fixed an inaccurate comment on posix_pedantic. Thu 12 Dec 1991 21:15:20 Jim Meyering (meyering at hal) * tr.c: Changed underscores to hyphens in long option name "sysv_string2_truncate". Wed Dec 11 13:33:34 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * tac.c (main): Set obscure_syntax to tell re_search to allocate memory for the group registers. Fri Dec 6 18:26:27 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * tac.c, sort.c, csplit.c [POSIX]: Use sigaction instead of signal, which POSIX doesn't have. * sort.c: Replace inthandler and huphandler with sighandler. * csplit.c (main): Only handle signals if they were not being ignored. * tr.c: POSIX_ME_HARDER -> POSIXLY_CORRECT. Wed Dec 4 00:47:47 1991 Jim Meyering (meyering at wombat) * tr.c (unquote): Reformat code so it doesn't go beyond column 80. * tr.c (squeeze_filter): Comment a little on why it's better to step through the input by two. * tr.c (set_initialize): Write a comment describing the function. * tr.c: Eliminated the variable `portability_warnings' and replaced references to it by references to `!posix_pedantic'. One of the uses of portability_warnings had been wrong. Tue Dec 3 14:03:35 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * tr.c: New program. Sun Dec 1 15:07:35 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * linebuffer.[ch] (freebuffer): New function (used by cron). Thu Oct 17 22:30:22 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * system.h, configure, Makefile.in: Don't include memory.h if STDC_HEADERS, removing need for MEMORY_H_MISSING. Thu 17 Oct 1991 16:53:07 Jim Meyering (meyering at wombat) * pr.c (print_page): REALLY fixed `extra newline at EOF' problem. Somehow, part of my patch didn't make it last time. Sat Oct 12 12:04:47 1991 David J. MacKenzie (djm at churchy.gnu.ai.mit.edu) * tail.c (pipe_lines, pipe_bytes): Initialize `first->next'. * cmp.c (cmp): Print EOF message to stderr, not stdout, for POSIX 1003.2.11.2. * sort.c (xfwrite): fwrite never returns < 0, so check if number written is number we asked to write. (fillbuf, main): fread never returns < 0, so check ferror instead. From Rainer Orth. Tue Oct 8 18:07:08 1991 Jim Meyering (meyering at churchy) * pr.c (print_page): Really fixed `extra newline at EOF' problem. * (store_columns): Fixed bug that caused `pr -b -2' to coredump on files of certain lengths. Fri Oct 4 22:30:25 1991 Jim Meyering (meyering at churchy) * pr.c (print_page): Fixed to not add single spurious newline at EOF when using -t. Wed Oct 2 01:02:05 1991 David J. MacKenzie (djm at apple-gunkies) * pr.c (print_page): Don't pad the page if -t given. * csplit.c (load_buffer), sort.c (mergefps): Use bcopy, not memcpy. Thu Sep 26 12:35:00 1991 David J. MacKenzie (djm at churchy.gnu.ai.mit.edu) * Version 1.1. * configure, system.h: Include memory.h if it works. * split.c: Allow `b' unit as well as `k' and `m'. * head.c, tail.c: Replace -b +blocks option with specifying units (b, k, or m) after the number. (parse_unit): New function. * fold.c (main): Check that -w arg is a number. * cut.c: +delimiter takes an arg. Mon Sep 16 14:52:38 1991 David J. MacKenzie (djm at churchy.gnu.ai.mit.edu) * pr.c (close_file): Don't close an already closed file. Thu Sep 12 00:14:43 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * memchr.c: New file. * configure: Check if it's needed. * csplit.c, gcsplit.1: New program. * pr.c (cleanup): Only free buffers if they were allocated. * sort.c [!USG && !STDC_HEADERS]: Declare memchr. Wed Sep 11 20:54:16 1991 Jim Meyering (meyering at churchy) * pr.c: The following 3 bugs appeared (at least) when printing a single file with the options `-3 -f'. * (print_white_space): Single spaces were being replaced with tabs. * (print_page): Some lines were getting too much white space at the beginning because spaces_not_printed wasn't being reset to 0. * (read_line): The single space between a truncated column on its left and the column on its right was omitted. Fixed so that previous value of input_position is restored before returning FALSE. Sat Sep 7 03:22:18 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * configure: Only remove /etc from PATH when it's not part of a larger name. Wed Sep 4 17:09:24 1991 David J. MacKenzie (djm at apple-gunkies) * linebuffer.c (readline): Fix incorrect recalculation of `end'. * head.c, tail.c: Replace `mode' variables and bitmasks with separate variables for each option. Mon Sep 2 04:00:37 1991 David J. MacKenzie (djm at apple-gunkies) * wc.c: New program. Sun Sep 1 01:18:38 1991 David J. MacKenzie (djm at apple-gunkies) * fold.c (fold_file): Read in an int, not a char, for EOF comparison. * configure: Check whether st_blksize is missing. * tac.c (save_stdin): Put copy of pipe input in TMPDIR if defined, instead of /tmp. Thu Aug 29 14:48:15 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * xwrite.c [POSIX]: unistd.h might require sys/types.h. Wed Aug 28 11:57:39 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * paste.c (main): Consider -d "" to be like -d "\0", for POSIX (if I read it right). * sort.c, join.c: New programs. * cut.c (set_field): Allow blanks as well as commas to separate numbers in ranges. Sun Aug 25 19:57:40 1991 Jim Meyering (meyering at apple-gunkies) * pr.c: Failure to open an input file is no longer a fatal error. A message is printed for each failed open. When printing in parallel, each failed open results in one fewer output column. Added POSIX -r option to suppress the message. * pr.c: Added variables: failed_opens, ignore_failed_opens. These changes were based in part on work by David MacKenzie. Sat Aug 24 15:27:39 1991 Jim Meyering (meyering at pogo) * pr.c: Complain if user gives both -m and -[0-9]+ options. Wed Aug 21 22:04:57 1991 David J. MacKenzie (djm at apple-gunkies) * Version 1.0. Mon Aug 19 00:16:51 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * expand.c: Rename some variables. (expand): Don't access value off end of array. * unexpand.c: Rename some variables. (unexpand): Don't access value off end of array. Instead of copying tabs verbatim and flushing pending spaces when one is reached, count them as the proper number of pending spaces. Instead of changing tabs to single spaces if the tabstop list is exhausted, print the rest of the line unchanged (for POSIX). Sat Aug 17 01:49:41 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * cut.c (cut_file), paste.c (paste_parallel, paste_serial): Clear EOF and error conditions on stdin so it can be reused. * expand.c, unexpand.c (parse_tabstops): Allow blanks as well as commas to separate tabstops, for POSIX. * expand.c (expand), unexpand.c (unexpand): Don't line-buffer the output; send it directly to stdout. * unexpand.c (main): Make -t stupidly imply -a for POSIX. (unexpand): If a tab stop list was given and we move past its end, copy the rest of the line verbatim. * split.c (convint): New function to allow 'm' and 'k' after byte counts. (main): Use it. Change -c option to -b for POSIX. Fri Aug 9 02:47:02 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * pr.c: Protect isdigit with isascii, if required. Tue Aug 6 21:42:25 1991 David J. MacKenzie (djm at wheat-chex) Most of the following is from Paul Eggert: * cat.c (main): If stdin is read, check close at end. * cmp.c (main): Check for stdin being closed. Check for close errors on stdin and stdout. (cmp): Return a value instead of exiting. * cut.c (cut_file): New function, from code in main. Check for read errors. (main): Check for close errors. * expand.c, unexpand.c (main): Check for close errors. (next_file): Go to next file if one can't be opened. Check for close errors. * head.c (main), tail.c (main): If stdin was read, check for close errors. * head.c (head_file), tail.c (tail_file): Check for close errors. * paste.c (main, paste_parallel, paste_serial), tac.c (main): Check for close errors. Close stdin if it was read. * split.c (main): Check for close errors. * configure, Makefile.in's: Support +srcdir option. Make config.status. Fix up clean targets. Wed Jul 31 01:32:59 1991 David J. MacKenzie (djm at hal) * linebuffer.h (struct linebuffer): Add a field to indicate the number of valid chars in the line. * linebuffer.c (initbuffer, readline): Fill it in. * uniq.c, comm.c: Use it. * pr.c (main): Check stdin and stdout fclose for errors. (init_parameters): If there's no room for header and footer, omit them rather than dying (for POSIX). (init_header): Take a file descriptor as additional arg. (init_fps): Change callers. Note when stdin is read. (open_file): For filename "-" use stdin. (close_file): Don't close stdin. Check close for errors. (print_char, char_to_clump): Use isprint instead of explicit comparisons. * memcmp.c: New file (needed for comm). * bcopy.c: New file (needed for fold). * system.h: Don't define bcopy as memcpy. * configure: Check for bcopy and memcmp. * uniq.c (main): Use "-" instead of NULL to mean stdin or stdout. (check_file): Use "-" instead of NULL to mean stdin or stdout. Check readline return instead of for NUL character to detect eof. Check fclose for errors. (find_field): Use linebuffer length, not NULs, to detect end of line. (different): New function, replaces compare. Uses memcmp instead of strncmp. (writeline): Use fwrite instead of fputs so NULs are preserved. * comm.c (compare_files): Return an error indication. Don't take a filename of NULL to mean stdin. Use memcmp instead of strcmp to allow for NULs. Check fclose for errors. (writeline): Use fwrite instead of fputs so NULs are preserved. * sum.c (sum_file): Take an arg indicating whether to print the filename, and don't take NULL meaning stdin. Set a flag when we read stdin. Check fclose return for errors. (main): If stdin was read, check fclose return for errors. Use filename of "-" if no args given. Thu Jul 25 15:17:10 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * fold.c: Rewritten from scratch for POSIX. Wed Jul 24 01:55:41 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * split.c (line_bytes_split): Use xmalloc instead of alloca. * system.h: Don't declare alloca. * tac.c, tail.c: Use SEEK_ instead of L_ for lseek. * system.h: Define SEEK_ macros if not defined. * pr.c: Rename variable `truncate' to avoid library function conflict. Tue Jul 23 13:21:48 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * linebuffer.c, linebuffer.h: New files. * comm.c, uniq.c (initbuffer, readline): Functions removed (use versions in linebuffer.c). Mon Jul 22 13:23:53 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu) * sum.c (sumfile): Always print 5 digits for second number, too. Interpret "-" to mean stdin. Sat Jul 20 14:24:40 1991 David J. MacKenzie (djm at bleen) * uniq.c: Use isblank instead of isspace, to support POSIX.2. * comm.c, pr.c, uniq.c (concat, fatal, error, pfatal_with_name, xmalloc, xrealloc): Functions removed. Sat Jul 13 02:04:53 1991 David J. MacKenzie (djm at geech.gnu.ai.mit.edu) * nl.c: Add long-named options. Doc fixes. Sat Jul 6 02:19:09 1991 David J. MacKenzie (djm at geech.gnu.ai.mit.edu) * expand.c, unexpand.c [STDC_HEADERS]: Include stdlib.h. * xwrite.c [POSIX]: Include unistd.h. [STDC_HEADERS]: Don't declare errno. Sun Jun 30 23:35:16 1991 David J. MacKenzie (djm at geech.gnu.ai.mit.edu) * uniq.c: Add long-named options. Remove marginally useful -z option (zero padded repeat counts). Thu Jun 27 16:31:45 1991 David J. MacKenzie (djm at geech.gnu.ai.mit.edu) * tail.c (tail_file), tac.c (save_stdin, tac_file), split.c (cwrite), head.c (head_file), cat.c (main): Check close return value for delayed error report due to NFS. Tue Jun 11 00:12:15 1991 David J. MacKenzie (djm at geech.gnu.ai.mit.edu) * cat.c: Replace "uchar" with "unsigned char", to avoid problems with various systems' typedefs. Thu Jun 6 12:54:26 1991 David J. MacKenzie (djm at geech.gnu.ai.mit.edu) * cat.c (cat): Interpret ENOTTY return from FIONREAD ioctl to mean operation is unsupported, for HP-UX 7.0. Sun Apr 14 21:49:17 1991 Richard Stallman (rms at mole.gnu.ai.mit.edu) * sum.c: Always print five digits for first number. Fri Mar 15 16:16:54 1991 David J. MacKenzie (djm at geech.ai.mit.edu) * cat.c, cmp.c: Don't use fileno(); not needed. Thu Jan 10 02:16:55 1991 David J. MacKenzie (djm at albert.ai.mit.edu) * tac.c, tail.c: Change _POSIX_SOURCE to POSIX. Thu Dec 27 00:06:45 1990 David J. MacKenzie (djm at egypt) * cut.c (cut_file_bytes, cut_file_fields): Make inbufp and outbufp global. (enlarge_line): Adjust inbufp and outbufp. Sun Sep 9 16:54:19 1990 David J. MacKenzie (djm at albert.ai.mit.edu) * cat.c: Declare free returning void, not int, so it doesn't bomb on Xenix. Mon Sep 3 22:23:57 1990 David J. MacKenzie (djm at coke) * tac.c: Print error messages before calling cleanup, not after. Tue Aug 28 18:05:24 1990 David J. MacKenzie (djm at albert.ai.mit.edu) * tac.c (cleanup): Return SIGTYPE, not int. Tue Aug 7 12:51:18 1990 David J. MacKenzie (djm at apple-gunkies) * cut.c (main, usage): Add -b and -n options for POSIX. (set_fields): Don't allow SPC or TAB as number separators. * paste.c (paste_parallel): If open of any file fails, quit (for POSIX). Mon Aug 6 22:14:13 1990 David J. MacKenzie (djm at apple-gunkies) * pr.c: Add POSIX -F option (same as -f). * uniq.c (check_file): Allow '-' to mean stdin or stdout. Mon Aug 6 14:43:30 1990 David J. MacKenzie (djm at pogo.ai.mit.edu) * head.c, tail.c: Change `chars' to `bytes' globally. (main, usage): Use POSIX.2 draft 10 option syntax. Sun Aug 5 11:51:12 1990 David J. MacKenzie (djm at pogo.ai.mit.edu) * cat.c (main): Don't delay error messages, so they appear where expected. (main, simple_cat, cat): Make errors in input files nonfatal. Sat Aug 4 10:11:30 1990 David J. MacKenzie (djm at pogo.ai.mit.edu) * cat.c: Remove -c option added for POSIX draft 9, since POSIX draft 10 removed it. * tac.c (tac_stdin): Use fstat instead of lseek to determine whether stdin is seekable, because lseek silently fails on some special files, like tty's. tail.c (tail_chars, tail_lines): Use fstat instead of lseek; don't turn off -f for non-regular files (assume the user knows what he's doing; it might work for fifo's and sockets). * paste.c (main): If no files given, use stdin. Don't let collapse_escapes write on string constant (delim default). (paste_parallel): Don't close stdin. * cut.c (main): Use standard input for filename of "-". * comm.c (compare_files): Allow '-' to mean stdin. Fri Aug 3 13:38:28 1990 David J. MacKenzie (djm at pogo.ai.mit.edu) * cut.c (enlarge_line): Take an arg giving the required amount of space. Change callers. (main): Don't allow -t'' without -f. Make `delim' unsigned to fix sign extension problem in comparison. Tue Jul 17 12:36:11 EDT 1990 Jay Fenlason (hack@ai.mit.edu) * pr.c Deleted excess whitespace from ends of lines. Modified to work with current version of getopt, which returns 1 instead of 0 for non-options. Reversed the meaning of the -f option, to be compatable with real pr. Sun Jul 8 00:39:31 1990 David J. MacKenzie (djm at apple-gunkies) * cmp.c (main, usage): Rename -L option to -c and don't have it imply -l. (printc): Take an arg to specify number of chars to pad to, for column alignment. (cmp): Respect flag_print_chars in default output format. Align columns for cmp -cl. Sat Jul 7 17:23:30 1990 David J. MacKenzie (djm at apple-gunkies) * cmp.c: For +show-chars, have getopt return 'L' so `flag_print_chars' gets set. Fri Jun 29 01:04:19 1990 David J. MacKenzie (djm at apple-gunkies) * tac.c (main): Initialize fastmap and translate fields of regex before compiling it. Fri Jun 22 00:38:20 1990 David J. MacKenzie (djm at albert.ai.mit.edu) * tac.c: Change +regexp to +regex for consistency with GNU find. Wed Jun 20 01:46:09 1990 David J. MacKenzie (djm at albert.ai.mit.edu) * cat.c (cat): If FIONREAD is available, only use it if it is supported by the filesystem that the file is on. Sun Jun 3 20:26:19 1990 David J. MacKenzie (djm at albert.ai.mit.edu) * cat.c (main): Add a variable to control whether the check for input file == output file is made, because no values of st_dev and st_ino should be assumed to be available for this purpose. Only do the check for regular files. * tac.c: Use bcopy instead of memcpy. Thu May 31 00:55:36 1990 David J. MacKenzie (djm at apple-gunkies) * head.c: Use longs instead of ints for file offsets, for 16 bit machines. Tue May 22 00:56:51 1990 David J. MacKenzie (djm at albert.ai.mit.edu) * cmp.c: Change some ints to longs for 16 bit machines. (bcmp_cnt): Make char-pointer counting slightly simpler. Sat May 12 01:16:42 1990 David J. MacKenzie (djm at albert.ai.mit.edu) * cat.c (main): Allow input file to be output file for devices (ttys, etc.). Check whether input file is output file when reading standard input. Print any error messages for standard input. * cmp.c (bcmp_cnt): Handle int comparisons correctly on 16 bit machines as well as 32 bit ones. * cmp.c, tail.c: Use longs instead of ints for file offsets. Fri May 11 02:11:03 1990 David J. MacKenzie (djm at albert.ai.mit.edu) * cmp.c: Fix some exit statuses for POSIX. Tue May 8 03:41:42 1990 David J. MacKenzie (djm at abyss) * tac.c: Use regular expressions as the record boundaries. Give better error messages. Reformat code and make it more readable. (main): Use getopt_long to parse options. (tac_stdin): Do not make a temporary file if standard input is a file. (tac_file): New function. (tac): Take an open file desc as an arg. (output): Rewrite to use its own efficient buffering. (xmalloc, xrealloc, xwrite): New functions. Sun Apr 8 20:33:20 1990 David J. MacKenzie (djm at albert.ai.mit.edu) * head.c, tail.c: Use `error' instead of `fatal_perror' and `nonfatal_perror'. Remove some unnecessary info from messages. Wed Mar 21 09:30:18 1990 David J. MacKenzie (djm at pogo.ai.mit.edu) * comm.c (main): Pass the list of files to compare_files as a char ** instead of a char *. (compare_files): Make arg a char **. * uniq.c: Declare some functions as void. Change global vars `countmode' and `mode' from ints to enums. (main): Use getopt to parse options and support POSIX options. Don't use integer_arg to parse numbers, since `-#' can't be parsed that way using getopt. (find_field): Use isspace for finding fields boundaries. Tue Mar 20 14:28:25 1990 David J. MacKenzie (djm at pogo.ai.mit.edu) * comm.c (main): Call usage if given bad option or wrong number of args. Exit with 0 status normally. (usage): New function. Declare some other functions as void. Wed Mar 14 10:48:40 1990 David J. MacKenzie (djm at rice-chex) * cmp.c (main, cmp, usage): Replace -q +quick option with -L +show-chars option to add ASCII representation of bytes to -l format. Tue Mar 13 00:50:14 1990 David J. MacKenzie (djm at rice-chex) * cmp.c (cmp): Change EOF message for POSIX compatibility. For -l format, clear bits > FF. Mon Mar 5 17:21:00 1990 David J. MacKenzie (djm at albert.ai.mit.edu) * tail.c: Move global `errors' into main instead of having nonfatal_perror set it. (tail, tail_chars, tail_file, tail_lines, pipe_chars, pipe_lines): Return an error status. (file_lines, start_chars, start_lines): Reverse the meaning of the return value. (tail_lines, tail_chars): Account for that reversal. Mon Mar 5 00:34:36 1990 David J. MacKenzie (djm at albert.ai.mit.edu) * head.c: Move global `errors' into main and have the various functions return an error status instead of setting it in nonfatal_perror. Sat Mar 3 11:27:27 1990 Torbj|rn Granlund (tege at echnaton) * cmp.c (cmp): Call function bcmp_cnt for flag == 0 (i.e. no options specified), to compare the two blocks and count newlines simultaneously. * cmp.c New function: bcmp_cnt. * cmp.c (main): Test if output is redirected to /dev/null, and assume `-s' if this is so. Tue Feb 20 17:09:19 1990 David J. MacKenzie (djm at albert.ai.mit.edu) * cat.c: Change `argbad' from a char to a short, so it will work on machines with unsigned chars. Sat Feb 10 02:16:40 1990 David J. MacKenzie (djm at albert.ai.mit.edu) * cmp.c (cmp): Rename `r' to `first_diff', and `x' to `smaller'. Remove unneccessary variable `c1'. If -l was given, increase `char_number' by the number of bytes read, after producing output, rather than by the offset of the first differing bytes, before producing output. Replace if-else-if constructions with case statements for clarity. (bcmp2): Rename `n' to `nread'. Wed Dec 20 01:32:06 1989 David J. MacKenzie (djm at hobbes.ai.mit.edu) * nl.c (proc_text): Use re_search instead of re_match. Tue Dec 19 01:26:34 1989 David J. MacKenzie (djm at hobbes.ai.mit.edu) * nl.c: Indent. Un-nest statements. Use GNU regexp functions instead of System V ones. Move function declarations together. (quit): Remove useless function. (program_name): New variable for error messages. (main): Use perror in error message. (xmalloc): New function to replace myalloc. (myalloc): Function removed. Global: use program_name and xmalloc. Sun Dec 17 00:36:36 1989 David J. MacKenzie (djm at hobbes.ai.mit.edu) * uniq.c: Declare some functions. (main): Initialize infile and outfile. Call usage if given invalid args. Normally exit with 0 status instead of garbage. (usage): New function to print usage message and exit. (check_file): Remove unused variable. (readline): Compare against EOF, not < 0. (xmalloc, xrealloc): Return char *, not int. Ok to return 0 if 0 bytes requested. (lb1, lb2): Remove unused global vars. (concat): Remove unused function. Sat Dec 16 15:15:50 1989 David J. MacKenzie (djm at hobbes.ai.mit.edu) * comm.c: Remove unused global variables lb1, lb2. (main): Remove unneeded variable. (compare_files): Remove unused arg. (readline): un-nest assignment. Test against EOF instead of < 0. (error): Print to stderr, not stdout. (xmalloc, xrealloc): Return char * instead of int. Returning 0 is ok if 0 bytes requested (ANSI C). Local Variables: mode: indented-text left-margin: 8 version-control: never End: textutils-1.12/Makefile.in100666 74504 13 10433 5770310433 14654 0ustar meyeringuser# Master Makefile for the GNU text 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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@ SHELL = /bin/sh DISTFILES = COPYING COPYING.LIB ChangeLog Makefile.in README INSTALL \ NEWS configure configure.in config.h.in mkinstalldirs install-sh \ stamp-h.in # Redundant stuff for making only selected programs. PROGS = cat cksum comm csplit cut expand fmt fold head join md5sum nl od \ paste pr sort split sum tac tail tr unexpand uniq wc # Subdirectories to run make in for the primary targets. SUBDIRS = lib src man doc .SUFFIXES: all check install install-exec install-data uninstall: config.h Makefile for subdir in $(SUBDIRS); do \ echo making $@ in $$subdir; \ (cd $$subdir && $(MAKE) $@) || exit 1; \ done info dvi: cd doc && $(MAKE) $@ installcheck: $(PROGS): cd lib && $(MAKE) all cd src && $(MAKE) $@ mostlyclean: mostlyclean-recursive mostlyclean-local clean: clean-recursive clean-local distclean: distclean-recursive distclean-local rm config.status maintainer-clean: maintainer-clean-recursive maintainer-clean-local rm config.status TAGS clean-recursive distclean-recursive \ mostlyclean-recursive maintainer-clean-recursive: for subdir in $(SUBDIRS); do \ target=`echo $@|sed 's/-recursive//'`; \ echo making $$target in $$subdir; \ (cd $$subdir && $(MAKE) $$target) || exit 1; \ done mostlyclean-local: clean-local: mostlyclean-local distclean-local: clean-local rm -f Makefile config.cache config.h config.log stamp-h distname maintainer-clean-local: distclean-local distname: src/version.c echo textutils-`sed -e '/version_string/!d' \ -e 's/[^0-9.]*\([-0-9.a-z]*\).*/\1/' -e q src/version.c` > $@-tmp mv $@-tmp $@ distdir = `cat distname` dist: $(DISTFILES) distname rm -rf $(distdir) mkdir $(distdir) for file in $(DISTFILES); do \ ln $$file $(distdir) \ || { echo copying $$file instead; cp -p $$file $(distdir);}; \ done for subdir in $(SUBDIRS); do \ mkdir $(distdir)/$$subdir || exit 1; \ (cd $$subdir && $(MAKE) $@) || exit 1; \ done tar --gzip -chvf $(distdir).tar.gz $(distdir) rm -rf $(distdir) distname # For the justification of the following Makefile rules, see node # `Automatic Remaking' in GNU Autoconf documentation. Makefile: config.status Makefile.in CONFIG_FILES=$@ CONFIG_HEADERS= ./config.status config.h: stamp-h stamp-h: config.status $(srcdir)/config.h.in CONFIG_FILES= CONFIG_HEADERS=config.h ./config.status config.status: configure ./config.status --recheck configure: configure.in cd $(srcdir) && autoconf config.h.in: stamp-h.in stamp-h.in: configure.in cd $(srcdir) && autoheader # Use echo instead of date to avoid spurious conflicts for # people who use CVS, since stamp-h.in is distributed. echo > $(srcdir)/$@ .PHONY: all check clean clean-local clean-recursive dist distclean \ distclean-local distclean-recursive dvi info install install-data \ install-exec installcheck mostlyclean mostlyclean-local \ mostlyclean-recursive maintainer-clean maintainer-clean-local \ maintainer-clean-recursive uninstall # 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: textutils-1.12/README100666 74504 13 3707 5747624436 13474 0ustar meyeringuserThese are the GNU text file (actually, file contents) processing utilities. Most of these programs have significant advantages over their Unix counterparts, such as greater speed, additional options, and fewer arbitrary limits. The programs that can be built with this package are: cat, cksum, comm, csplit, cut, expand, fold, head, join, nl, od paste, pr, sort, split, sum, tac, tail, tr, unexpand, uniq, and wc. The cmp program has moved to the GNU diff distribution. 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 several of these utilities. For instance, when built with the obsolete getopt functions, `tail +10' and `uniq +3' will give usage errors instead of the expected results. There is a known bug in the pr program. It doesn't work properly when the first character in an input file is a form feed. The textutils are intended to be POSIX.2 compliant (with BSD and other extensions), like the rest of the GNU system. They are almost there, but a few incompatibilities remain. The comprehensive Texinfo documentation for these programs is not finished yet, and needs to be rewritten. In the interim, the skeletal man pages provided with this distribution will have to serve. 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. For general documentation on the coding and usage standards this distribution follows, see the GNU standards document on prep.ai.mit.edu:pub/gnu/standards.*, especially the `Makefile Conventions', `Configuration', and `User Interfaces' sections. Mail suggestions and bug reports for these programs to bug-gnu-utils@prep.ai.mit.edu. textutils-1.12/INSTALL100666 12241 13 16446 5716157366 13316 0ustar rolanduserBasic Installation ================== These are generic installation instructions. The `configure' shell script attempts to guess correct values for various system-dependent variables used during compilation. It uses those values to create a `Makefile' in each directory of the package. It may also create one or more `.h' files containing system-dependent definitions. Finally, it creates a shell script `config.status' that you can run in the future to recreate the current configuration, a file `config.cache' that saves the results of its tests to speed up reconfiguring, and a file `config.log' containing compiler output (useful mainly for debugging `configure'). If you need to do unusual things to compile the package, please try to figure out how `configure' could check whether to do them, and mail diffs or instructions to the address given in the `README' so they can be considered for the next release. If at some point `config.cache' contains results you don't want to keep, you may remove or edit it. The file `configure.in' is used to create `configure' by a program called `autoconf'. You only need `configure.in' if you want to change it or regenerate `configure' using a newer version of `autoconf'. The simplest way to compile this package is: 1. `cd' to the directory containing the package's source code and type `./configure' to configure the package for your system. 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 running, it prints some messages telling which features it is checking for. 2. Type `make' to compile the package. 3. Optionally, type `make check' to run any self-tests that come with the package. 4. Type `make install' to install the programs and any data files and documentation. 5. You can remove the program binaries and object files from the source code directory by typing `make clean'. To also remove the files that `configure' created (so you can compile the package for a different kind of computer), type `make distclean'. There is also a `make maintainer-clean' target, but that is intended mainly for the package's developers. If you use it, you may have to get all sorts of other programs in order to regenerate files that came with the distribution. Compilers and Options ===================== Some systems require unusual options for compilation or linking that the `configure' script does not know about. You can give `configure' initial values for variables by setting them in the environment. Using a Bourne-compatible shell, you can do that on the command line like this: CC=c89 CFLAGS=-O2 LIBS=-lposix ./configure Or on systems that have the `env' program, you can do it like this: env CPPFLAGS=-I/usr/local/include LDFLAGS=-s ./configure Compiling For Multiple Architectures ==================================== You can compile the package for more than one kind of computer at the same time, by placing the object files for each architecture in their own directory. To do this, 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 you have to use a `make' that does not supports the `VPATH' variable, you have to compile the package for one architecture at a time in the source code directory. After you have installed the package for one architecture, use `make distclean' before reconfiguring for another architecture. Installation Names ================== 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'. You can specify separate installation prefixes for architecture-specific files and architecture-independent files. If you give `configure' the option `--exec-prefix=PATH', the package will use PATH as the prefix for installing programs and libraries. Documentation and other data files will still use the regular prefix. If the package supports it, you can cause programs to be installed with an extra prefix or suffix on their names by giving `configure' the option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'. Optional Features ================= Some packages pay attention to `--enable-FEATURE' options to `configure', where FEATURE indicates an optional part of the package. They may also pay attention to `--with-PACKAGE' options, where PACKAGE is something like `gnu-as' or `x' (for the X Window System). The `README' should mention any `--enable-' and `--with-' options that the package recognizes. For packages that use the X Window System, `configure' can usually find the X include and library files automatically, but if it doesn't, you can use the `configure' options `--x-includes=DIR' and `--x-libraries=DIR' to specify their locations. Specifying the System Type ========================== There may be some features `configure' can not figure out automatically, but needs to determine by the type of host the package will run on. Usually `configure' can figure that out, but if it prints a message saying it can not guess the host type, give it the `--host=TYPE' option. TYPE can either be a short name for the system type, such as `sun4', or a canonical name with three fields: CPU-COMPANY-SYSTEM See the file `config.sub' for the possible values of each field. If `config.sub' isn't included in this package, then this package doesn't need to know the host type. If you are building compiler tools for cross-compiling, you can also use the `--target=TYPE' option to select the type of system they will produce code for and the `--build=TYPE' option to select the type of system on which you are compiling the package. Sharing Defaults ================ If you want to set default values for `configure' scripts to share, you can create a site shell script called `config.site' that gives default values for variables like `CC', `cache_file', and `prefix'. `configure' looks for `PREFIX/share/config.site' if it exists, then `PREFIX/etc/config.site' if it exists. Or, you can set the `CONFIG_SITE' environment variable to the location of the site script. A warning: not all `configure' scripts look for a site script. Operation Controls ================== `configure' recognizes the following options to control how it operates. `--cache-file=FILE' Use and save the results of the tests in FILE instead of `./config.cache'. Set FILE to `/dev/null' to disable caching, for debugging `configure'. `--help' Print a summary of the options to `configure', and exit. `--quiet' `--silent' `-q' Do not print messages saying which checks are being made. `--srcdir=DIR' Look for the package's source code in directory DIR. Usually `configure' can determine that directory automatically. `--version' Print the version of Autoconf used to generate the `configure' script, and exit. `configure' also accepts some other, not widely useful, options. textutils-1.12/NEWS100666 74504 13 10114 5770037366 13315 0ustar meyeringuserUser-visible changes in release 1.12 * sort no longer reports spurious errors on Ultrix systems * new program: md5sum * all --help messages have been improved * join's -a1 and -a2 options work * tr '[:upper:]' '[:lower:]' no longer reads uninitialized memory * sort properly handles command line arguments like `+7.2n' * fmt properly formats paragraphs not terminated by a newline * tail -f flushes stdout before sleeping so that it will output partial lines sooner * sort properly orders fields where one field is a proper prefix of the other * sort properly interprets field offsets specified via the -k option * dd, od, and tail work on systems for which off_t is long long (e.g. BSD4.4) * wc is faster when not counting words * wc now works even when file pointer isn't at beginning of file * expand no longer seg faults with very long tab lists User-visible changes in release 1.11 * fmt is built User-visible changes in release 1.10 * skeletal texinfo documentation (mainly just the `invoking' nodes) * new program: fmt * tail -f on multiple files reports file truncation * tail -q has been fixed so it never prints headers * wc -c is much faster when operating on non-regular files * unexpand gives a diagnostic (rather than a segfault) when given a name of a nonexistent file. * cat, csplit, head, split, sum, tac, tail, tr, and wc no longer fail gratuitously when continued after a suspended read or write system call. * cut interprets -d '' to mean `use the NUL byte as the delimiter' rather than reporting that no delimiter was specified and failing. * `echo a:b:c: | cut -d: -f3,4' prints `c:'. Before it printed just `c'. * cut has been rewritten, is markedly faster for large inputs, and passes a fairly large test suite. * sort properly handles the argument to the -T option. Major changes in release 1.9.1: * cut no longer ignores the last line of input when that line lacks a trailing newline character Major changes in release 1.9: * `echo a:b:c: | cut -d: -f3-' prints `c:' and `echo a:b | cut -d: -f1' prints `a'. * the command `printf '\t\n' |fold -w n' now terminates. Before, it wouldn't stop for n less than 8. * sort accepts and ignores -y[string] options for compatibilty with Solaris. * cat -v /dev/null works on more systems * od's --compatible (-C) flag renamed to --traditional (no short option) * --help and --version exit successfully * --help gives a one-line description of each option and shows the correspondence between short and long-named options. * fix bug in cut. Now `echo 'a:b:c:' | cut -d: -f3-' works. Before it printed `c' instead of `c:' * csplit allows repeat counts to be specified via `{*}'. * csplit accepts a new option, --suffix=format that supercedes the --digits option. The --digits option will continue to work. * csplit accepts a new option, --elide-empty-files. * 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. Major changes in release 1.8: * added non-ANSIfied version of memchr.c from GNU libc. Major changes in release 1.7: * none Major changes in release 1.6: * with the --version option programs print the version and exit immediately * pr -2a really terminates * pr -n produces multi-column output Major changes in release 1.5: * sort is 8-bit clean * sort's -n and -M options no longer imply -b * several bugs in sort have been fixed * all programs accept --help and --version options * od --compatible accepts pre-POSIX arguments * pr -2a terminates Major changes in release 1.4: * add od and cksum programs * move cmp to GNU diff distribution * tail -f works for multiple files * pr prints the file name in error messages * fix some off by 1 errors in pr and fold * optimize wc -c on regular files * sort handles `-' argument correctly * sort supports -T option * tr ranges like a-a work * tr x '' fails gracefully * default sum output format is BSD compatible * paste -d '' works textutils-1.12/configure100777 74504 13 160152 5770035144 14545 0ustar meyeringuser#! /bin/sh # Guess values for system-dependent variables and create Makefiles. # Generated automatically using autoconf version 2.4 # Copyright (C) 1992, 1993, 1994 Free Software Foundation, Inc. # # This configure script is free software; the Free Software Foundation # gives unlimited permission to copy, distribute and modify it. # Defaults: ac_help= ac_default_prefix=/usr/local # Any additions from configure.in: # Initialize some variables set by options. # The variables have the same names as the options, with # dashes changed to underlines. build=NONE cache_file=./config.cache exec_prefix=NONE host=NONE no_create= nonopt=NONE no_recursion= prefix=NONE program_prefix=NONE program_suffix=NONE program_transform_name=s,x,x, silent= site= srcdir= target=NONE verbose= x_includes=NONE x_libraries=NONE # Initialize some other variables. subdirs= 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 case "$ac_option" in -*=*) ac_optarg=`echo "$ac_option" | sed 's/[-_a-zA-Z0-9]*=//'` ;; *) ac_optarg= ;; esac # Accept the important Cygnus configure options, so we can diagnose typos. case "$ac_option" in -build | --build | --buil | --bui | --bu | --b) ac_prev=build ;; -build=* | --build=* | --buil=* | --bui=* | --bu=* | --b=*) build="$ac_optarg" ;; -cache-file | --cache-file | --cache-fil | --cache-fi \ | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) ac_prev=cache_file ;; -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) cache_file="$ac_optarg" ;; -disable-* | --disable-*) ac_feature=`echo $ac_option|sed -e 's/-*disable-//'` # Reject names that are not valid shell variable names. if test -n "`echo $ac_feature| sed 's/[-a-zA-Z0-9_]//g'`"; then { echo "configure: error: $ac_feature: invalid feature name" 1>&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 are not valid shell variable names. if test -n "`echo $ac_feature| sed 's/[-_a-zA-Z0-9]//g'`"; then { echo "configure: error: $ac_feature: invalid feature name" 1>&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'" ;; -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) # Obsolete; use --with-gas. with_gas=yes ;; -help | --help | --hel | --he) # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat << EOF Usage: configure [options] [host] Options: [defaults in brackets after descriptions] Configuration: --cache-file=FILE cache test results in FILE --help print this message --no-create do not create output files --quiet, --silent do not print \`checking...' messages --version print the version of autoconf that created configure Directory and file names: --prefix=PREFIX install architecture-independent files in PREFIX [$ac_default_prefix] --exec-prefix=PREFIX install architecture-dependent files in PREFIX [same as prefix] --srcdir=DIR find the sources in DIR [configure dir or ..] --program-prefix=PREFIX prepend PREFIX to installed program names --program-suffix=SUFFIX append SUFFIX to installed program names --program-transform-name=PROGRAM run sed PROGRAM on installed program names Host type: --build=BUILD configure for building on BUILD [BUILD=HOST] --host=HOST configure for HOST [guessed] --target=TARGET configure for TARGET [TARGET=HOST] Features and packages: --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) --enable-FEATURE[=ARG] include FEATURE [ARG=yes] --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 --enable and --with options recognized:$ac_help EOF exit 0 ;; -host | --host | --hos | --ho) ac_prev=host ;; -host=* | --host=* | --hos=* | --ho=*) host="$ac_optarg" ;; -nfp | --nfp | --nf) # Obsolete; use --without-fp. with_fp=no ;; -no-create | --no-create | --no-creat | --no-crea | --no-cre \ | --no-cr | --no-c) no_create=yes ;; -no-recursion | --no-recursion | --no-recursio | --no-recursi \ | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) no_recursion=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 ;; -site | --site | --sit) ac_prev=site ;; -site=* | --site=* | --sit=*) site="$ac_optarg" ;; -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 2.4" exit 0 ;; -with-* | --with-*) ac_package=`echo $ac_option|sed -e 's/-*with-//' -e 's/=.*//'` # Reject names that are not valid shell variable names. if test -n "`echo $ac_package| sed 's/[-_a-zA-Z0-9]//g'`"; then { echo "configure: error: $ac_package: invalid package name" 1>&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 are not valid shell variable names. if test -n "`echo $ac_package| sed 's/[-a-zA-Z0-9_]//g'`"; then { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; } fi ac_package=`echo $ac_package| sed 's/-/_/g'` eval "with_${ac_package}=no" ;; --x) # Obsolete; use --with-x. with_x=yes ;; -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: error: $ac_option: invalid option; use --help to show usage" 1>&2; exit 1; } ;; *) if test -n "`echo $ac_option| sed 's/[-a-z0-9.]//g'`"; then echo "configure: warning: $ac_option: invalid host type" 1>&2 fi if test "x$nonopt" != xNONE; then { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; } fi nonopt="$ac_option" ;; esac done if test -n "$ac_prev"; then { echo "configure: error: missing argument to --`echo $ac_prev | sed 's/_/-/g'`" 1>&2; exit 1; } fi trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15 # File descriptor usage: # 0 standard input # 1 file creation # 2 errors and warnings # 3 some systems may open it to /dev/tty # 4 used on the Kubota Titan # 6 checking for... messages and results # 5 compiler messages saved in config.log if test "$silent" = yes; then exec 6>/dev/null else exec 6>&1 fi exec 5>./config.log echo "\ This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. " 1>&5 # Strip out --no-create and --no-recursion so they do not pile up. # Also quote any args containing shell metacharacters. ac_configure_args= for ac_arg do case "$ac_arg" in -no-create | --no-create | --no-creat | --no-crea | --no-cre \ | --no-cr | --no-c) ;; -no-recursion | --no-recursion | --no-recursio | --no-recursi \ | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) ;; *" "*|*" "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?]*) ac_configure_args="$ac_configure_args '$ac_arg'" ;; *) ac_configure_args="$ac_configure_args $ac_arg" ;; esac done # NLS nuisances. # Only set LANG and LC_ALL to C if already set. # 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/fold.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 its parent. 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 else ac_srcdir_defaulted=no fi if test ! -r $srcdir/$ac_unique_file; then if test "$ac_srcdir_defaulted" = yes; then { echo "configure: error: can not find sources in $ac_confdir or .." 1>&2; exit 1; } else { echo "configure: error: can not find sources in $srcdir" 1>&2; exit 1; } fi fi srcdir=`echo "${srcdir}" | sed 's%\([^/]\)/*$%\1%'` # Prefer explicitly selected file to automatically selected ones. if test -z "$CONFIG_SITE"; then if test "x$prefix" != xNONE; then CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site" else CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site" fi fi for ac_site_file in $CONFIG_SITE; do if test -r "$ac_site_file"; then echo "loading site script $ac_site_file" . "$ac_site_file" fi done if test -r "$cache_file"; then echo "loading cache $cache_file" . $cache_file else echo "creating cache $cache_file" > $cache_file fi ac_ext=c # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options. ac_cpp='$CPP $CPPFLAGS' ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5 2>&5' ac_link='${CC-cc} -o conftest $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5 2>&5' if (echo "testing\c"; echo 1,2,3) | grep c >/dev/null; then # Stardent Vistra SVR4 grep lacks -e, says ghazi@caip.rutgers.edu. if (echo -n testing; echo 1,2,3) | sed s/-n/xn/ | grep xn >/dev/null; then ac_n= ac_c=' ' ac_t=' ' else ac_n=-n ac_c= ac_t= fi else ac_n= ac_c='\c' ac_t= fi if test "$program_transform_name" = s,x,x,; then program_transform_name= else # Double any \ or $. echo 's,\\,\\\\,g; s,\$,$$,g' > conftestsed program_transform_name="`echo $program_transform_name|sed -f conftestsed`" rm -f conftestsed fi test "$program_prefix" != NONE && program_transform_name="s,^,${program_prefix},; $program_transform_name" # Use a double $ so make ignores it. test "$program_suffix" != NONE && program_transform_name="s,\$\$,${program_suffix},; $program_transform_name" # sed with no file args requires a program. test "$program_transform_name" = "" && program_transform_name="s,x,x," # Extract the first word of "gcc", so it can be a program name with args. set dummy gcc; ac_word=$2 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else 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 ac_cv_prog_CC="gcc" break fi done IFS="$ac_save_ifs" test -z "$ac_cv_prog_CC" && ac_cv_prog_CC="cc" fi fi CC="$ac_cv_prog_CC" if test -n "$CC"; then echo "$ac_t""$CC" 1>&6 else echo "$ac_t""no" 1>&6 fi echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6 if eval "test \"`echo '$''{'ac_cv_prog_gcc'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.c <&5 | egrep yes >/dev/null 2>&1; then ac_cv_prog_gcc=yes else ac_cv_prog_gcc=no fi fi echo "$ac_t""$ac_cv_prog_gcc" 1>&6 if test $ac_cv_prog_gcc = yes; then GCC=yes if test "${CFLAGS+set}" != set; then echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6 if eval "test \"`echo '$''{'ac_cv_prog_gcc_g'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else echo 'void f(){}' > conftest.c if test -z "`${CC-cc} -g -c conftest.c 2>&1`"; then ac_cv_prog_gcc_g=yes else ac_cv_prog_gcc_g=no fi rm -f conftest* fi echo "$ac_t""$ac_cv_prog_gcc_g" 1>&6 if test $ac_cv_prog_gcc_g = yes; then CFLAGS="-g -O" else CFLAGS="-O" fi fi else GCC= test "${CFLAGS+set}" = set || CFLAGS="-g" fi ac_aux_dir= for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do if test -f $ac_dir/install-sh; then ac_aux_dir=$ac_dir ac_install_sh="$ac_aux_dir/install-sh -c" break elif test -f $ac_dir/install.sh; then ac_aux_dir=$ac_dir ac_install_sh="$ac_aux_dir/install.sh -c" break fi done if test -z "$ac_aux_dir"; then { echo "configure: error: can not find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." 1>&2; exit 1; } fi ac_config_guess=$ac_aux_dir/config.guess ac_config_sub=$ac_aux_dir/config.sub ac_configure=$ac_aux_dir/configure # This should be Cygnus configure. # Find a good install program. We prefer a C program (faster), # so one script is as good as another. But avoid the broken or # incompatible versions: # SysV /etc/install, /usr/sbin/install # SunOS /usr/etc/install # IRIX /sbin/install # AIX /bin/install # AFS /usr/afsws/bin/install, which mishandles nonexistent args # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff" # ./install, which can be erroneously created by make from ./install.sh. echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6 if test -z "$INSTALL"; then if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:" for ac_dir in $PATH; do # Account for people who put trailing slashes in PATH elements. case "$ac_dir/" in /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;; *) # OSF1 and SCO ODT 3.0 have their own names for install. for ac_prog in ginstall 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 ac_cv_path_install="$ac_dir/$ac_prog -c" break 2 fi fi done ;; esac done IFS="$ac_save_ifs" # As a last resort, use the slow shell script. test -z "$ac_cv_path_install" && ac_cv_path_install="$ac_install_sh" fi INSTALL="$ac_cv_path_install" fi echo "$ac_t""$INSTALL" 1>&6 # Use test -z because SunOS4 sh mishandles braces in ${var-val}. # It thinks the first close brace ends the variable substitution. test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}' test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' echo $ac_n "checking whether ${MAKE-make} sets \${MAKE}""... $ac_c" 1>&6 set dummy ${MAKE-make}; ac_make=$2 if eval "test \"`echo '$''{'ac_cv_prog_make_${ac_make}_set'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else 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 eval ac_cv_prog_make_${ac_make}_set=yes else eval ac_cv_prog_make_${ac_make}_set=no fi rm -f conftestmake fi if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then echo "$ac_t""yes" 1>&6 SET_MAKE= else echo "$ac_t""no" 1>&6 SET_MAKE="MAKE=${MAKE-make}" fi echo $ac_n "checking how to run the C preprocessor""... $ac_c" 1>&6 # On Suns, sometimes $CPP names a directory. if test -n "$CPP" && test -d "$CPP"; then CPP= fi if test -z "$CPP"; then if eval "test \"`echo '$''{'ac_cv_prog_CPP'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else # This must be in double quotes, not single quotes, because CPP may get # substituted into the Makefile and "${CC-cc}" will confuse make. CPP="${CC-cc} -E" # On the NeXT, cc -E runs the code through the compiler's parser, # not just through cpp. cat > conftest.$ac_ext < Syntax Error EOF eval "$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" ac_err=`grep -v '^ *+' conftest.out` if test -z "$ac_err"; then : else echo "$ac_err" >&5 rm -rf conftest* CPP="${CC-cc} -E -traditional-cpp" cat > conftest.$ac_ext < Syntax Error EOF eval "$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" ac_err=`grep -v '^ *+' conftest.out` if test -z "$ac_err"; then : else echo "$ac_err" >&5 rm -rf conftest* CPP=/lib/cpp fi rm -f conftest* fi rm -f conftest* ac_cv_prog_CPP="$CPP" fi CPP="$ac_cv_prog_CPP" else ac_cv_prog_CPP="$CPP" fi echo "$ac_t""$CPP" 1>&6 if test $ac_cv_prog_gcc = yes; then echo $ac_n "checking whether ${CC-cc} needs -traditional""... $ac_c" 1>&6 if eval "test \"`echo '$''{'ac_cv_prog_gcc_traditional'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else ac_pattern="Autoconf.*'x'" cat > conftest.$ac_ext < Autoconf TIOCGETP EOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | egrep "$ac_pattern" >/dev/null 2>&1; then rm -rf conftest* ac_cv_prog_gcc_traditional=yes else rm -rf conftest* ac_cv_prog_gcc_traditional=no fi rm -f conftest* if test $ac_cv_prog_gcc_traditional = no; then cat > conftest.$ac_ext < Autoconf TCGETA EOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | egrep "$ac_pattern" >/dev/null 2>&1; then rm -rf conftest* ac_cv_prog_gcc_traditional=yes fi rm -f conftest* fi fi echo "$ac_t""$ac_cv_prog_gcc_traditional" 1>&6 if test $ac_cv_prog_gcc_traditional = yes; then CC="$CC -traditional" fi fi # Extract the first word of "ranlib", so it can be a program name with args. set dummy ranlib; ac_word=$2 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else if test -n "$RANLIB"; then ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test. else 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 ac_cv_prog_RANLIB="ranlib" break fi done IFS="$ac_save_ifs" test -z "$ac_cv_prog_RANLIB" && ac_cv_prog_RANLIB=":" fi fi RANLIB="$ac_cv_prog_RANLIB" if test -n "$RANLIB"; then echo "$ac_t""$RANLIB" 1>&6 else echo "$ac_t""no" 1>&6 fi echo $ac_n "checking for AIX""... $ac_c" 1>&6 cat > conftest.$ac_ext <&5 | egrep "yes" >/dev/null 2>&1; then rm -rf conftest* echo "$ac_t""yes" 1>&6; cat >> confdefs.h <<\EOF #define _ALL_SOURCE 1 EOF else rm -rf conftest* echo "$ac_t""no" 1>&6 fi rm -f conftest* ac_safe=`echo "minix/config.h" | tr './\055' '___'` echo $ac_n "checking for minix/config.h""... $ac_c" 1>&6 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < EOF eval "$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" ac_err=`grep -v '^ *+' conftest.out` if test -z "$ac_err"; then rm -rf conftest* eval "ac_cv_header_$ac_safe=yes" else echo "$ac_err" >&5 rm -rf conftest* eval "ac_cv_header_$ac_safe=no" fi rm -f conftest* fi if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then echo "$ac_t""yes" 1>&6 MINIX=yes else echo "$ac_t""no" 1>&6 MINIX= fi if test "$MINIX" = yes; then cat >> confdefs.h <<\EOF #define _POSIX_SOURCE 1 EOF cat >> confdefs.h <<\EOF #define _POSIX_1_SOURCE 2 EOF cat >> confdefs.h <<\EOF #define _MINIX 1 EOF fi echo $ac_n "checking for POSIXized ISC""... $ac_c" 1>&6 if test -d /etc/conf/kconfig.d && grep _POSIX_VERSION /usr/include/sys/unistd.h >/dev/null 2>&1 then echo "$ac_t""yes" 1>&6 ISC=yes # If later tests want to check for ISC. cat >> confdefs.h <<\EOF #define _POSIX_SOURCE 1 EOF if test "$GCC" = yes; then CC="$CC -posix" else CC="$CC -Xp" fi else echo "$ac_t""no" 1>&6 ISC= fi for ac_hdr in limits.h string.h memory.h fcntl.h unistd.h do ac_safe=`echo "$ac_hdr" | tr './\055' '___'` echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < EOF eval "$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" ac_err=`grep -v '^ *+' conftest.out` if test -z "$ac_err"; then rm -rf conftest* eval "ac_cv_header_$ac_safe=yes" else echo "$ac_err" >&5 rm -rf conftest* eval "ac_cv_header_$ac_safe=no" fi rm -f conftest* fi if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then echo "$ac_t""yes" 1>&6 ac_tr_hdr=HAVE_`echo $ac_hdr | tr '[a-z]./\055' '[A-Z]___'` cat >> confdefs.h <&6 fi done echo $ac_n "checking whether stat file-mode macros are broken""... $ac_c" 1>&6 if eval "test \"`echo '$''{'ac_cv_header_stat_broken'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < #include #if defined(S_ISBLK) && defined(S_IFDIR) # if S_ISBLK (S_IFDIR) You lose. # endif #endif #if defined(S_ISBLK) && defined(S_IFCHR) # if S_ISBLK (S_IFCHR) You lose. # endif #endif #if defined(S_ISLNK) && defined(S_IFREG) # if S_ISLNK (S_IFREG) You lose. # endif #endif #if defined(S_ISSOCK) && defined(S_IFREG) # if S_ISSOCK (S_IFREG) You lose. # endif #endif EOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | egrep "You lose" >/dev/null 2>&1; then rm -rf conftest* ac_cv_header_stat_broken=yes else rm -rf conftest* ac_cv_header_stat_broken=no fi rm -f conftest* fi echo "$ac_t""$ac_cv_header_stat_broken" 1>&6 if test $ac_cv_header_stat_broken = yes; then cat >> confdefs.h <<\EOF #define STAT_MACROS_BROKEN 1 EOF fi # If we cannot run a trivial program, we must be cross compiling. echo $ac_n "checking whether cross-compiling""... $ac_c" 1>&6 if eval "test \"`echo '$''{'ac_cv_c_cross'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else if test "$cross_compiling" = yes; then ac_cv_c_cross=yes else cat > conftest.$ac_ext </dev/null; then ac_cv_c_cross=no else ac_cv_c_cross=yes fi fi rm -fr conftest* fi cross_compiling=$ac_cv_c_cross echo "$ac_t""$ac_cv_c_cross" 1>&6 echo $ac_n "checking for ANSI C header files""... $ac_c" 1>&6 if eval "test \"`echo '$''{'ac_cv_header_stdc'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < #include #include #include EOF eval "$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" ac_err=`grep -v '^ *+' conftest.out` if test -z "$ac_err"; then rm -rf conftest* ac_cv_header_stdc=yes else echo "$ac_err" >&5 rm -rf conftest* ac_cv_header_stdc=no fi rm -f conftest* if test $ac_cv_header_stdc = yes; then # SunOS 4.x string.h does not declare mem*, contrary to ANSI. cat > conftest.$ac_ext < EOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | egrep "memchr" >/dev/null 2>&1; then : else rm -rf conftest* ac_cv_header_stdc=no fi rm -f conftest* fi if test $ac_cv_header_stdc = yes; then # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. cat > conftest.$ac_ext < EOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | egrep "free" >/dev/null 2>&1; then : else rm -rf conftest* ac_cv_header_stdc=no fi rm -f conftest* fi if test $ac_cv_header_stdc = yes; then # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. if test "$cross_compiling" = yes; then ac_cv_header_stdc=no else 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_link if test -s conftest && (./conftest; exit) 2>/dev/null; then : else ac_cv_header_stdc=no fi fi rm -fr conftest* fi fi echo "$ac_t""$ac_cv_header_stdc" 1>&6 if test $ac_cv_header_stdc = yes; then cat >> confdefs.h <<\EOF #define STDC_HEADERS 1 EOF fi echo $ac_n "checking whether byte ordering is bigendian""... $ac_c" 1>&6 if eval "test \"`echo '$''{'ac_cv_c_bigendian'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else ac_cv_c_bigendian=unknown # See if sys/param.h defines the BYTE_ORDER macro. cat > conftest.$ac_ext < #include int main() { return 0; } int t() { #if !BYTE_ORDER || !BIG_ENDIAN || !LITTLE_ENDIAN bogus endian macros #endif ; return 0; } EOF if eval $ac_compile; then rm -rf conftest* # It does; now see whether it defined to BIG_ENDIAN or not. cat > conftest.$ac_ext < #include int main() { return 0; } int t() { #if BYTE_ORDER != BIG_ENDIAN not big endian #endif ; return 0; } EOF if eval $ac_compile; then rm -rf conftest* ac_cv_c_bigendian=yes else rm -rf conftest* ac_cv_c_bigendian=no fi rm -f conftest* fi rm -f conftest* if test $ac_cv_c_bigendian = unknown; then if test "$cross_compiling" = yes; then { echo "configure: error: can not run test program while cross compiling" 1>&2; exit 1; } else cat > conftest.$ac_ext </dev/null; then ac_cv_c_bigendian=no else ac_cv_c_bigendian=yes fi fi rm -fr conftest* fi fi echo "$ac_t""$ac_cv_c_bigendian" 1>&6 if test $ac_cv_c_bigendian = yes; then cat >> confdefs.h <<\EOF #define WORDS_BIGENDIAN 1 EOF fi echo $ac_n "checking for working const""... $ac_c" 1>&6 if eval "test \"`echo '$''{'ac_cv_c_const'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext <j = 5; } { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */ const int foo = 10; } ; return 0; } EOF if eval $ac_compile; then rm -rf conftest* ac_cv_c_const=yes else rm -rf conftest* ac_cv_c_const=no fi rm -f conftest* fi echo "$ac_t""$ac_cv_c_const" 1>&6 if test $ac_cv_c_const = no; then cat >> confdefs.h <<\EOF #define const EOF fi echo $ac_n "checking for long double""... $ac_c" 1>&6 if eval "test \"`echo '$''{'ac_cv_c_long_double'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else if test "$GCC" = yes; then ac_cv_c_long_double=yes else if test "$cross_compiling" = yes; then { echo "configure: error: can not run test program while cross compiling" 1>&2; exit 1; } else cat > conftest.$ac_ext </dev/null; then ac_cv_c_long_double=yes else ac_cv_c_long_double=no fi fi rm -fr conftest* fi fi echo "$ac_t""$ac_cv_c_long_double" 1>&6 if test $ac_cv_c_long_double = yes; then cat >> confdefs.h <<\EOF #define HAVE_LONG_DOUBLE 1 EOF fi ac_header_dirent=no for ac_hdr in dirent.h sys/ndir.h sys/dir.h ndir.h do ac_safe=`echo "$ac_hdr" | tr './\055' '___'` echo $ac_n "checking for $ac_hdr that defines DIR""... $ac_c" 1>&6 if eval "test \"`echo '$''{'ac_cv_header_dirent_$ac_safe'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < #include <$ac_hdr> int main() { return 0; } int t() { DIR *dirp = 0; ; return 0; } EOF if eval $ac_compile; then rm -rf conftest* eval "ac_cv_header_dirent_$ac_safe=yes" else rm -rf conftest* eval "ac_cv_header_dirent_$ac_safe=no" fi rm -f conftest* fi if eval "test \"`echo '$ac_cv_header_dirent_'$ac_safe`\" = yes"; then echo "$ac_t""yes" 1>&6 ac_tr_hdr=HAVE_`echo $ac_hdr | tr '[a-z]./\055' '[A-Z]___'` cat >> confdefs.h <&6 fi done # Two versions of opendir et al. are in -ldir and -lx on SCO Xenix. if test $ac_header_dirent = dirent.h; then echo $ac_n "checking for -ldir""... $ac_c" 1>&6 if eval "test \"`echo '$''{'ac_cv_lib_dir'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else ac_save_LIBS="$LIBS" LIBS="-ldir $LIBS" cat > conftest.$ac_ext <&6 LIBS="$LIBS -ldir" else echo "$ac_t""no" 1>&6 fi else echo $ac_n "checking for -lx""... $ac_c" 1>&6 if eval "test \"`echo '$''{'ac_cv_lib_x'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else ac_save_LIBS="$LIBS" LIBS="-lx $LIBS" cat > conftest.$ac_ext <&6 LIBS="$LIBS -lx" else echo "$ac_t""no" 1>&6 fi fi echo $ac_n "checking for st_blksize in struct stat""... $ac_c" 1>&6 if eval "test \"`echo '$''{'ac_cv_struct_st_blksize'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < #include int main() { return 0; } int t() { struct stat s; s.st_blksize; ; return 0; } EOF if eval $ac_compile; then rm -rf conftest* ac_cv_struct_st_blksize=yes else rm -rf conftest* ac_cv_struct_st_blksize=no fi rm -f conftest* fi echo "$ac_t""$ac_cv_struct_st_blksize" 1>&6 if test $ac_cv_struct_st_blksize = yes; then cat >> confdefs.h <<\EOF #define HAVE_ST_BLKSIZE 1 EOF fi echo $ac_n "checking for off_t""... $ac_c" 1>&6 if eval "test \"`echo '$''{'ac_cv_type_off_t'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < #if STDC_HEADERS #include #endif EOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | egrep "off_t" >/dev/null 2>&1; then rm -rf conftest* ac_cv_type_off_t=yes else rm -rf conftest* ac_cv_type_off_t=no fi rm -f conftest* fi echo "$ac_t""$ac_cv_type_off_t" 1>&6 if test $ac_cv_type_off_t = no; then cat >> confdefs.h <<\EOF #define off_t long EOF fi echo $ac_n "checking return type of signal handlers""... $ac_c" 1>&6 if eval "test \"`echo '$''{'ac_cv_type_signal'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < #include #ifdef signal #undef signal #endif #ifdef __cplusplus extern "C" #endif void (*signal ()) (); int main() { return 0; } int t() { int i; ; return 0; } EOF if eval $ac_compile; then rm -rf conftest* ac_cv_type_signal=void else rm -rf conftest* ac_cv_type_signal=int fi rm -f conftest* fi echo "$ac_t""$ac_cv_type_signal" 1>&6 cat >> confdefs.h <&6 if eval "test \"`echo '$''{'ac_cv_type_size_t'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < #if STDC_HEADERS #include #endif EOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | egrep "size_t" >/dev/null 2>&1; then rm -rf conftest* ac_cv_type_size_t=yes else rm -rf conftest* ac_cv_type_size_t=no fi rm -f conftest* fi echo "$ac_t""$ac_cv_type_size_t" 1>&6 if test $ac_cv_type_size_t = no; then cat >> confdefs.h <<\EOF #define size_t unsigned EOF fi for ac_func in strerror isascii strchr strrchr do echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < /* Override any gcc2 internal prototype to avoid an error. */ char $ac_func(); 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 $ac_func(); #endif ; return 0; } EOF if eval $ac_link; then rm -rf conftest* eval "ac_cv_func_$ac_func=yes" else rm -rf conftest* eval "ac_cv_func_$ac_func=no" fi rm -f conftest* fi if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then echo "$ac_t""yes" 1>&6 ac_tr_func=HAVE_`echo $ac_func | tr '[a-z]' '[A-Z]'` cat >> confdefs.h <&6 fi done # The Ultrix 4.2 mips builtin alloca declared by alloca.h only works # for constant arguments. Useless! echo $ac_n "checking for working alloca.h""... $ac_c" 1>&6 if eval "test \"`echo '$''{'ac_cv_header_alloca_h'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < int main() { return 0; } int t() { char *p = alloca(2 * sizeof(int)); ; return 0; } EOF if eval $ac_link; then rm -rf conftest* ac_cv_header_alloca_h=yes else rm -rf conftest* ac_cv_header_alloca_h=no fi rm -f conftest* fi echo "$ac_t""$ac_cv_header_alloca_h" 1>&6 if test $ac_cv_header_alloca_h = yes; then cat >> confdefs.h <<\EOF #define HAVE_ALLOCA_H 1 EOF fi echo $ac_n "checking for alloca""... $ac_c" 1>&6 if eval "test \"`echo '$''{'ac_cv_func_alloca'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < # else # ifdef _AIX #pragma alloca # else # ifndef alloca /* predefined by HP cc +Olibcalls */ char *alloca (); # endif # endif # endif #endif int main() { return 0; } int t() { char *p = (char *) alloca(1); ; return 0; } EOF if eval $ac_link; then rm -rf conftest* ac_cv_func_alloca=yes else rm -rf conftest* ac_cv_func_alloca=no fi rm -f conftest* fi echo "$ac_t""$ac_cv_func_alloca" 1>&6 if test $ac_cv_func_alloca = yes; then cat >> confdefs.h <<\EOF #define HAVE_ALLOCA 1 EOF fi if test $ac_cv_func_alloca = no; 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 cat >> confdefs.h <<\EOF #define C_ALLOCA 1 EOF echo $ac_n "checking whether alloca needs Cray hooks""... $ac_c" 1>&6 if eval "test \"`echo '$''{'ac_cv_os_cray'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext <&5 | egrep "webecray" >/dev/null 2>&1; then rm -rf conftest* ac_cv_os_cray=yes else rm -rf conftest* ac_cv_os_cray=no fi rm -f conftest* fi echo "$ac_t""$ac_cv_os_cray" 1>&6 if test $ac_cv_os_cray = yes; then for ac_func in _getb67 GETB67 getb67; do echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < /* Override any gcc2 internal prototype to avoid an error. */ char $ac_func(); 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 $ac_func(); #endif ; return 0; } EOF if eval $ac_link; then rm -rf conftest* eval "ac_cv_func_$ac_func=yes" else rm -rf conftest* eval "ac_cv_func_$ac_func=no" fi rm -f conftest* fi if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then echo "$ac_t""yes" 1>&6 cat >> confdefs.h <&6 fi done fi echo $ac_n "checking stack direction for C alloca""... $ac_c" 1>&6 if eval "test \"`echo '$''{'ac_cv_c_stack_direction'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else if test "$cross_compiling" = yes; then ac_cv_c_stack_direction=0 else cat > conftest.$ac_ext < addr) ? 1 : -1; } main () { exit (find_stack_direction() < 0); } EOF eval $ac_link if test -s conftest && (./conftest; exit) 2>/dev/null; then ac_cv_c_stack_direction=1 else ac_cv_c_stack_direction=-1 fi fi rm -fr conftest* fi echo "$ac_t""$ac_cv_c_stack_direction" 1>&6 cat >> confdefs.h <&6 if eval "test \"`echo '$''{'ac_cv_func_memcmp'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else if test "$cross_compiling" = yes; then ac_cv_func_memcmp=no else cat > conftest.$ac_ext </dev/null; then ac_cv_func_memcmp=yes else ac_cv_func_memcmp=no fi fi rm -fr conftest* fi echo "$ac_t""$ac_cv_func_memcmp" 1>&6 test $ac_cv_func_memcmp = no && LIBOBJS="$LIBOBJS memcmp.o" echo $ac_n "checking for vprintf""... $ac_c" 1>&6 if eval "test \"`echo '$''{'ac_cv_func_vprintf'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < /* Override any gcc2 internal prototype to avoid an error. */ char vprintf(); 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_vprintf) || defined (__stub___vprintf) choke me #else vprintf(); #endif ; return 0; } EOF if eval $ac_link; then rm -rf conftest* eval "ac_cv_func_vprintf=yes" else rm -rf conftest* eval "ac_cv_func_vprintf=no" fi rm -f conftest* fi if eval "test \"`echo '$ac_cv_func_'vprintf`\" = yes"; then echo "$ac_t""yes" 1>&6 cat >> confdefs.h <<\EOF #define HAVE_VPRINTF 1 EOF else echo "$ac_t""no" 1>&6 fi if test "$ac_cv_func_vprintf" != yes; then echo $ac_n "checking for _doprnt""... $ac_c" 1>&6 if eval "test \"`echo '$''{'ac_cv_func__doprnt'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < /* Override any gcc2 internal prototype to avoid an error. */ char _doprnt(); 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__doprnt) || defined (__stub____doprnt) choke me #else _doprnt(); #endif ; return 0; } EOF if eval $ac_link; then rm -rf conftest* eval "ac_cv_func__doprnt=yes" else rm -rf conftest* eval "ac_cv_func__doprnt=no" fi rm -f conftest* fi if eval "test \"`echo '$ac_cv_func_'_doprnt`\" = yes"; then echo "$ac_t""yes" 1>&6 cat >> confdefs.h <<\EOF #define HAVE_DOPRNT 1 EOF else echo "$ac_t""no" 1>&6 fi fi for ac_func in memcpy memmove memcmp memset stpcpy strtoul do echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < /* Override any gcc2 internal prototype to avoid an error. */ char $ac_func(); 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 $ac_func(); #endif ; return 0; } EOF if eval $ac_link; then rm -rf conftest* eval "ac_cv_func_$ac_func=yes" else rm -rf conftest* eval "ac_cv_func_$ac_func=no" fi rm -f conftest* fi if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then echo "$ac_t""yes" 1>&6 : else echo "$ac_t""no" 1>&6 LIBOBJS="$LIBOBJS ${ac_func}.o" fi done trap '' 1 2 15 cat > confcache <<\EOF # This file is a shell script that caches the results of configure # tests run on this system so they can be shared between configure # scripts and configure runs. It is not useful on other systems. # If it contains results you don't want to keep, you may remove or edit it. # # By default, configure uses ./config.cache as the cache file, # creating it if it does not exist already. You can give configure # the --cache-file=FILE option to use a different cache file; that is # what configure does when it calls configure scripts in # subdirectories, so they share the cache. # Giving --cache-file=/dev/null disables caching, for debugging configure. # config.status only pays attention to the cache file if you give it the # --recheck option to rerun configure. # EOF # Ultrix sh set writes to stderr and can't be redirected directly, # and sets the high bit in the cache file unless we assign to the vars. (set) 2>&1 | sed -n "s/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=\${\1='\2'}/p" \ >> confcache if cmp -s $cache_file confcache; then : else if test -w $cache_file; then echo "updating cache $cache_file" cat confcache > $cache_file else echo "not updating unwritable cache $cache_file" fi fi rm -f confcache trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15 test "x$prefix" = xNONE && prefix=$ac_default_prefix # Let make expand exec_prefix. test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' # 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 trap 'rm -f $CONFIG_STATUS conftest*; exit 1' 1 2 15 DEFS=-DHAVE_CONFIG_H # Without the "./", some shells look in PATH for config.status. : ${CONFIG_STATUS=./config.status} echo creating $CONFIG_STATUS rm -f $CONFIG_STATUS cat > $CONFIG_STATUS </dev/null | sed 1q`: # # $0 $ac_configure_args # # Compiler output produced by configure, useful for debugging # configure, is in ./config.log if it exists. 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 $ac_configure_args --no-create --no-recursion" exec \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion ;; -version | --version | --versio | --versi | --vers | --ver | --ve | --v) echo "$CONFIG_STATUS generated by autoconf version 2.4" exit 0 ;; -help | --help | --hel | --he | --h) echo "\$ac_cs_usage"; exit 0 ;; *) echo "\$ac_cs_usage"; exit 1 ;; esac done ac_given_srcdir=$srcdir ac_given_INSTALL="$INSTALL" trap 'rm -fr `echo "Makefile doc/Makefile lib/Makefile man/Makefile src/Makefile config.h" | sed "s/:[^ ]*//g"` conftest*; exit 1' 1 2 15 # Protect against being on the right side of a sed subst in config.status. sed 's/%@/@@/; s/@%/@@/; s/%g$/@g/; /@g$/s/[\\\\&%]/\\\\&/g; s/@@/%@/; s/@@/@%/; s/@g$/%g/' > conftest.subs <<\CEOF $ac_vpsub $extrasub s%@CFLAGS@%$CFLAGS%g s%@CPPFLAGS@%$CPPFLAGS%g s%@CXXFLAGS@%$CXXFLAGS%g s%@DEFS@%$DEFS%g s%@LDFLAGS@%$LDFLAGS%g s%@LIBS@%$LIBS%g s%@exec_prefix@%$exec_prefix%g s%@prefix@%$prefix%g s%@program_transform_name@%$program_transform_name%g s%@CC@%$CC%g s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g s%@INSTALL_DATA@%$INSTALL_DATA%g s%@SET_MAKE@%$SET_MAKE%g s%@CPP@%$CPP%g s%@RANLIB@%$RANLIB%g s%@ALLOCA@%$ALLOCA%g s%@LIBOBJS@%$LIBOBJS%g CEOF EOF cat >> $CONFIG_STATUS <> $CONFIG_STATUS <<\EOF for ac_file in .. $CONFIG_FILES; do if test "x$ac_file" != x..; then # Support "outfile[:infile]", defaulting infile="outfile.in". case "$ac_file" in *:*) ac_file_in=`echo "$ac_file"|sed 's%.*:%%'` ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;; *) ac_file_in="${ac_file}.in" ;; esac # Adjust relative srcdir, etc. for subdirectories. # 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="/`echo $ac_dir|sed 's%^\./%%'`" # A "../" for each directory in $ac_dir_suffix. ac_dots=`echo $ac_dir_suffix|sed 's%/[^/]*%../%g'` else ac_dir_suffix= ac_dots= fi case "$ac_given_srcdir" in .) srcdir=. if test -z "$ac_dots"; 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 case "$ac_given_INSTALL" in [/$]*) INSTALL="$ac_given_INSTALL" ;; *) INSTALL="$ac_dots$ac_given_INSTALL" ;; esac echo creating "$ac_file" rm -f "$ac_file" configure_input="Generated automatically from `echo $ac_file_in|sed 's%.*/%%'` by configure." case "$ac_file" in *Makefile*) ac_comsub="1i\\ # $configure_input" ;; *) ac_comsub= ;; esac sed -e "$ac_comsub s%@configure_input@%$configure_input%g s%@srcdir@%$srcdir%g s%@top_srcdir@%$top_srcdir%g s%@INSTALL@%$INSTALL%g " -f conftest.subs $ac_given_srcdir/$ac_file_in > $ac_file fi; done rm -f conftest.subs # These sed commands 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. # # 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' CONFIG_HEADERS=${CONFIG_HEADERS-"config.h"} for ac_file in .. $CONFIG_HEADERS; do if test "x$ac_file" != x..; then # Support "outfile[:infile]", defaulting infile="outfile.in". case "$ac_file" in *:*) ac_file_in=`echo "$ac_file"|sed 's%.*:%%'` ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;; *) ac_file_in="${ac_file}.in" ;; esac echo creating $ac_file rm -f conftest.frag conftest.in conftest.out cp $ac_given_srcdir/$ac_file_in conftest.in EOF # Transform confdefs.h into a sed script conftest.vals that substitutes # the proper values into config.h.in to produce config.h. And first: # Protect against being on the right side of a sed subst in config.status. # Protect against being in an unquoted here document in config.status. rm -f conftest.vals cat > conftest.hdr <<\EOF s/[\\&%]/\\&/g s%[\\$`]%\\&%g s%#define \([A-Za-z_][A-Za-z0-9_]*\) \(.*\)%${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD}%gp s%ac_d%ac_u%gp s%ac_u%ac_e%gp EOF sed -n -f conftest.hdr confdefs.h > conftest.vals rm -f conftest.hdr # This sed command replaces #undef 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. cat >> conftest.vals <<\EOF s%^[ ]*#[ ]*undef[ ][ ]*[a-zA-Z_][a-zA-Z_0-9]*%/* & */% EOF # Break up conftest.vals because some shells have a limit on # the size of here documents, and old seds have small limits too. # Maximum number of lines to put in a single here document. ac_max_here_lines=12 rm -f conftest.tail while : do ac_lines=`grep -c . conftest.vals` # grep -c gives empty output for an empty file on some AIX systems. if test -z "$ac_lines" || test "$ac_lines" -eq 0; then break; fi # Write a limited-size here document to conftest.frag. echo ' cat > conftest.frag <> $CONFIG_STATUS sed ${ac_max_here_lines}q conftest.vals >> $CONFIG_STATUS echo 'CEOF sed -f conftest.frag conftest.in > conftest.out rm -f conftest.in mv conftest.out conftest.in ' >> $CONFIG_STATUS sed 1,${ac_max_here_lines}d conftest.vals > conftest.tail rm -f conftest.vals mv conftest.tail conftest.vals done rm -f conftest.vals cat >> $CONFIG_STATUS <<\EOF rm -f conftest.frag conftest.h echo "/* $ac_file. Generated automatically by configure. */" > conftest.h cat conftest.in >> conftest.h rm -f conftest.in if cmp -s $ac_file conftest.h 2>/dev/null; then echo "$ac_file is unchanged" rm -f conftest.h else rm -f $ac_file mv conftest.h $ac_file fi fi; done echo > stamp-h exit 0 EOF chmod +x $CONFIG_STATUS rm -fr confdefs* $ac_clean_files test "$no_create" = yes || ${CONFIG_SHELL-/bin/sh} $CONFIG_STATUS || exit 1 textutils-1.12/configure.in100644 74504 13 1560 5747624436 15114 0ustar meyeringuserdnl Process this file with autoconf to produce a configure script. AC_INIT(src/fold.c) AC_CONFIG_HEADER(config.h) AC_ARG_PROGRAM dnl Checks for programs. AC_PROG_CC AC_PROG_INSTALL AC_PROG_MAKE_SET AC_PROG_CPP AC_PROG_GCC_TRADITIONAL AC_PROG_RANLIB AC_AIX AC_MINIX AC_ISC_POSIX dnl Checks for header files. AC_CHECK_HEADERS(limits.h string.h memory.h fcntl.h unistd.h) AC_HEADER_STAT AC_HEADER_STDC dnl Checks for typedefs, structures, and compiler characteristics. AC_C_BIGENDIAN AC_C_CONST AC_C_LONG_DOUBLE AC_HEADER_DIRENT AC_STRUCT_ST_BLKSIZE AC_TYPE_OFF_T AC_TYPE_SIGNAL AC_TYPE_SIZE_T dnl Checks for library functions. AC_CHECK_FUNCS(strerror isascii strchr strrchr) AC_FUNC_ALLOCA AC_FUNC_MEMCMP AC_FUNC_VPRINTF AC_REPLACE_FUNCS(memcpy memmove memcmp memset stpcpy strtoul) AC_OUTPUT(Makefile doc/Makefile lib/Makefile man/Makefile src/Makefile, [echo > stamp-h])dnl textutils-1.12/config.h.in100666 74504 13 6113 5733312456 14620 0ustar meyeringuser/* 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 alloca, as a function or macro. */ #undef HAVE_ALLOCA /* Define if you have and it should be used (not on Ultrix). */ #undef HAVE_ALLOCA_H /* Define if you don't have vprintf but do have _doprnt. */ #undef HAVE_DOPRNT /* Define if the `long double' type works. */ #undef HAVE_LONG_DOUBLE /* Define if your struct stat has st_blksize. */ #undef HAVE_ST_BLKSIZE /* Define if you have the vprintf function. */ #undef HAVE_VPRINTF /* Define if on MINIX. */ #undef _MINIX /* Define to `long' if doesn't define. */ #undef off_t /* 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 as the return type of signal handlers (int or void). */ #undef RETSIGTYPE /* 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 your processor stores words with the most significant byte first (like Motorola and SPARC, unlike Intel and VAX). */ #undef WORDS_BIGENDIAN /* Define if you have the isascii function. */ #undef HAVE_ISASCII /* Define if you have the strchr function. */ #undef HAVE_STRCHR /* Define if you have the strerror function. */ #undef HAVE_STRERROR /* Define if you have the strrchr function. */ #undef HAVE_STRRCHR /* Define if you have the header file. */ #undef HAVE_DIRENT_H /* Define if you have the header file. */ #undef HAVE_FCNTL_H /* Define if you have the header file. */ #undef HAVE_LIMITS_H /* Define if you have the header file. */ #undef HAVE_MEMORY_H /* Define if you have the header file. */ #undef HAVE_NDIR_H /* Define if you have the header file. */ #undef HAVE_STRING_H /* Define if you have the header file. */ #undef HAVE_SYS_DIR_H /* Define if you have the header file. */ #undef HAVE_SYS_NDIR_H /* Define if you have the header file. */ #undef HAVE_UNISTD_H textutils-1.12/mkinstalldirs100555 21570 1 1212 5716156043 14557 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 textutils-1.12/install-sh100555 21623 13 11244 5716156334 13540 0ustar mibuser#! /bin/sh # # install - install a program, script, or datafile # This comes from X11R5. # # Calling this script install-sh is preferred over install.sh, to prevent # `make' implicit rules from creating a file called install from it # when there is no Makefile. # # 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 textutils-1.12/stamp-h.in100666 74504 13 1 5747625154 14413 0ustar meyeringuser textutils-1.12/lib/ 40777 74504 13 0 5771033536 13246 5ustar meyeringusertextutils-1.12/lib/Makefile.in100666 74504 13 5063 5770310757 15416 0ustar meyeringuser# Makefile for library files used by GNU text 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. SHELL = /bin/sh srcdir = @srcdir@ VPATH = @srcdir@ CC = @CC@ AR = ar RANLIB = @RANLIB@ DEFS = @DEFS@ CFLAGS = @CFLAGS@ YACC = @YACC@ SOURCES = regex.c error.c full-write.c getopt.c getopt1.c \ linebuffer.c long-options.c memchr.c safe-read.c xmalloc.c \ alloca.c bcopy.c memcmp.c memcpy.c memmove.c memset.c stpcpy.c \ strtol.c strtoul.c xstrtol.c xstrtoul.c # Always link in the fast GNU memchr; it speeds up sort, especially on HP-UX. OBJECTS = regex.o error.o full-write.o getopt.o getopt1.o \ linebuffer.o long-options.o memchr.o safe-read.o \ xmalloc.o xstrtol.o xstrtoul.o @LIBOBJS@ @ALLOCA@ DISTFILES = Makefile.in error.h getopt.h linebuffer.h long-options.h regex.h \ xstrtol.h xstrtoul.h $(SOURCES) all: libtu.a .SUFFIXES: .SUFFIXES: .c .o .c.o: $(CC) -c $(CPPFLAGS) $(DEFS) -I.. -I$(srcdir) $(CFLAGS) $< subdir = lib Makefile: ../config.status Makefile.in cd .. && CONFIG_FILES=$(subdir)/$@ CONFIG_HEADERS= ./config.status installdirs: install install-exec install-data: all uninstall: TAGS: $(SOURCES) etags $(SOURCES) check: clean: rm -f *.a *.o mostlyclean: clean distclean: clean rm -f Makefile maintainer-clean: distclean rm -f TAGS distdir = ../`cat ../distname`/$(subdir) dist: $(DISTFILES) for file in $(DISTFILES); do \ ln $$file $(distdir) \ || { echo copying $$file instead; cp -p $$file $(distdir);}; \ done libtu.a: $(OBJECTS) rm -f $@ $(AR) cr $@ $(OBJECTS) -$(RANLIB) $@ $(OBJECTS): ../config.h getopt1.o: getopt.h regex.o: regex.h linebuffer.o: linebuffer.h .PHONY: all check clean dist distclean install install-data install-exec \ installdirs maintainer-clean mostlyclean uninstall # 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: textutils-1.12/lib/error.h100444 12241 1 3043 5757202412 14522 0ustar rolanddaemon/* error.h -- declaration for error-reporting function Copyright (C) 1995 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 _error_h_ #define _error_h_ #ifndef __attribute__ /* This feature is available in gcc versions 2.5 and later. */ # if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 5) || __STRICT_ANSI__ # define __attribute__(Spec) /* empty */ # endif /* The __-protected variants of `format' and `printf' attributes are accepted by gcc versions 2.6.4 (effectively 2.7) and later. */ # if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 7) # define __format__ format # define __printf__ printf # endif #endif #if __STDC__ void error (int, int, const char *, ...) \ __attribute__ ((__format__ (__printf__, 3, 4))); #else void error (); #endif /* This variable is incremented each time `error' is called. */ extern unsigned int error_message_count; #endif /* _error_h_ */ textutils-1.12/lib/getopt.h100444 12241 1 10526 5655157302 14723 0ustar rolanddaemon/* Declarations for getopt. Copyright (C) 1989, 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. */ #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 defined (__STDC__) && __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 defined (__STDC__) && __STDC__ #ifdef __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 /* __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 /* __STDC__ */ #ifdef __cplusplus } #endif #endif /* _GETOPT_H */ textutils-1.12/lib/linebuffer.h100666 74504 13 3025 5770311466 15635 0ustar meyeringuser/* linebuffer.h -- declarations for reading arbitrarily long lines 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* A `struct linebuffer' holds a line of text. */ struct linebuffer { long size; /* Allocated. */ long length; /* Used. */ char *buffer; }; #undef __P #if defined (__STDC__) && __STDC__ #define __P(x) x #else #define __P(x) () #endif /* Initialize linebuffer LINEBUFFER for use. */ void initbuffer __P ((struct linebuffer *linebuffer)); /* Read an arbitrarily long line of text from STREAM into LINEBUFFER. Remove any newline. Does not null terminate. Return LINEBUFFER, except at end of file return 0. */ struct linebuffer *readline __P ((struct linebuffer *linebuffer, FILE *stream)); /* Free linebuffer LINEBUFFER and its data, all allocated with malloc. */ void freebuffer __P ((struct linebuffer *)); textutils-1.12/lib/long-options.h100666 74504 13 367 5733313761 16131 0ustar meyeringuser#undef __P #if defined (__STDC__) && __STDC__ #define __P(args) args #else #define __P(args) () #endif void parse_long_options __P ((int _argc, char **_argv, const char *_command_name, const char *_version_string, void (*_usage) (int))); textutils-1.12/lib/regex.h100444 12241 1 44607 5756460272 14547 0ustar rolanddaemon/* Definitions for data structures and routines for the regular expression library, version 0.12. Copyright (C) 1985, 89, 90, 91, 92, 93, 95 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 . */ #if !defined (_POSIX_C_SOURCE) && !defined (_POSIX_SOURCE) && defined (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) /* If this bit is set, succeed as soon as we match the whole pattern, without further backtracking. */ #define RE_NO_POSIX_BACKTRACKING (RE_UNMATCHED_RIGHT_PAREN_ORD << 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; /* 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)); #ifdef _REGEX_RE_COMP /* 4.2 bsd compatibility. */ extern char *re_comp _RE_ARGS ((const char *)); extern int re_exec _RE_ARGS ((const char *)); #endif /* 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: */ textutils-1.12/lib/xstrtol.h100644 74504 13 3261 5730645213 15225 0ustar meyeringuser#ifndef _xstrtol_h_ #define _xstrtol_h_ 1 #if STRING_TO_UNSIGNED # define __xstrtol xstrtoul # define __strtol strtoul # define __unsigned unsigned # define __ZLONG_MAX ULONG_MAX #else # define __xstrtol xstrtol # define __strtol strtol # define __unsigned /* empty */ # define __ZLONG_MAX LONG_MAX #endif #undef __P #if defined (__STDC__) && __STDC__ #define __P(x) x #else #define __P(x) () #endif enum strtol_error { LONGINT_OK, LONGINT_INVALID, LONGINT_INVALID_SUFFIX_CHAR, LONGINT_OVERFLOW }; typedef enum strtol_error strtol_error; strtol_error __xstrtol __P ((const char *s, char **ptr, int base, __unsigned long int *val, const char *valid_suffixes)); #define _STRTOL_ERROR(exit_code, str, argument_type_string, err) \ do \ { \ switch ((err)) \ { \ case LONGINT_OK: \ abort (); \ \ case LONGINT_INVALID: \ error ((exit_code), 0, "invalid %s `%s'", \ (argument_type_string), (str)); \ break; \ \ case LONGINT_INVALID_SUFFIX_CHAR: \ error ((exit_code), 0, "invalid character following %s `%s'", \ (argument_type_string), (str)); \ break; \ \ case LONGINT_OVERFLOW: \ /* FIXME: make this message dependent on STRING_TO_UNSIGNED */\ error ((exit_code), 0, "%s `%s' larger than maximum long int",\ (argument_type_string), (str)); \ break; \ } \ } \ while (0) #define STRTOL_FATAL_ERROR(str, argument_type_string, err) \ _STRTOL_ERROR (2, str, argument_type_string, err) #define STRTOL_FAIL_WARN(str, argument_type_string, err) \ _STRTOL_ERROR (0, str, argument_type_string, err) #endif /* _xstrtol_h_ */ textutils-1.12/lib/xstrtoul.h100644 74504 13 172 5667264174 15404 0ustar meyeringuser#ifndef _xstrtoul_h_ #define _xstrtoul_h_ 1 #define STRING_TO_UNSIGNED 1 #include "xstrtol.h" #endif /* _xstrtoul_h_ */ textutils-1.12/lib/regex.c100444 75424 1 527535 5764116103 14276 0ustar kwzhdaemon/* 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, 1995 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 #include #endif /* We need this for `regex.h', and perhaps for the Emacs include files. */ #include /* This is for other GNU distributions with internationalized messages. */ #if HAVE_LIBINTL_H || defined (_LIBC) # include #else # define gettext(msgid) (msgid) #endif /* 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" #else /* not emacs */ /* If we are not linking with Emacs proper, we can't use the relocating allocator even if config.h says that we can. */ #undef REL_ALLOC #if defined (STDC_HEADERS) || defined (_LIBC) #include #else char *malloc (); char *realloc (); #endif /* When used in Emacs's lib-src, we need to get bzero and bcopy somehow. If nothing else has been done, use the method below. */ #ifdef INHIBIT_STRING_HEADER #if !(defined (HAVE_BZERO) && defined (HAVE_BCOPY)) #if !defined (bzero) && !defined (bcopy) #undef INHIBIT_STRING_HEADER #endif #endif #endif /* This is the normal way of making sure we have a bcopy and a bzero. This is used in most programs--a few other programs avoid this by defining INHIBIT_STRING_HEADER. */ #ifndef INHIBIT_STRING_HEADER #if HAVE_STRING_H || STDC_HEADERS || defined (_LIBC) #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 SWITCH_ENUM_BUG #define SWITCH_ENUM_CAST(x) ((int)(x)) #else #define SWITCH_ENUM_CAST(x) (x) #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 (void *)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) #define REGEX_FREE free #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) /* No need to do anything to free, after alloca. */ #define REGEX_FREE(arg) ((void)0) /* Do nothing! But inhibit gcc warning. */ #endif /* not REGEX_MALLOC */ /* Define how to allocate the failure stack. */ #ifdef REL_ALLOC #define REGEX_ALLOCATE_STACK(size) \ r_alloc (&failure_stack_ptr, (size)) #define REGEX_REALLOCATE_STACK(source, osize, nsize) \ r_re_alloc (&failure_stack_ptr, (nsize)) #define REGEX_FREE_STACK(ptr) \ r_alloc_free (&failure_stack_ptr) #else /* not REL_ALLOC */ #ifdef REGEX_MALLOC #define REGEX_ALLOCATE_STACK malloc #define REGEX_REALLOCATE_STACK(source, osize, nsize) realloc (source, nsize) #define REGEX_FREE_STACK free #else /* not REGEX_MALLOC */ #define REGEX_ALLOCATE_STACK alloca #define REGEX_REALLOCATE_STACK(source, osize, nsize) \ REGEX_REALLOCATE (source, osize, nsize) /* No need to explicitly free anything. */ #define REGEX_FREE_STACK(arg) #endif /* not REGEX_MALLOC */ #endif /* not REL_ALLOC */ /* 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. */ typedef enum { no_op = 0, /* Succeed right away--no more backtracking. */ succeed, /* Followed by one byte giving n, then by n literal bytes. */ exactn, /* 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) /* 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; putchar (i - 1); while (i < (1 << BYTEWIDTH) && fastmap[i]) { was_a_range = 1; i++; } if (was_a_range) { printf ("-"); putchar (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 ('/'); putchar (*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) { putchar (last); in_range = 0; } if (! in_range) putchar (c); last = c; } if (in_range) putchar (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++) putchar (string1[this_char]); where = string2; } for (this_char = where - string2; this_char < size2; this_char++) putchar (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. */ /* This has no initializer because initialized variables in Emacs become read-only after dumping. */ reg_syntax_t re_syntax_options; /* 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. POSIX doesn't require that we do anything for REG_NOERROR, but why not be nice? */ static const char *re_error_msgid[] = { "Success", /* 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 processes 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 /* When using GNU C, we are not REALLY using the C alloca, no matter what config.h may say. So don't take precautions for it. */ #ifdef __GNUC__ #undef C_ALLOCA #endif /* The match routines may not allocate if (1) they would do it with malloc and (2) it's not safe for them to use malloc. Note that if REL_ALLOC is defined, matching would not use malloc for the failure stack, but we would still use it for the register vectors; so REL_ALLOC should not affect this. */ #if (defined (C_ALLOCA) || defined (REGEX_MALLOC)) && defined (emacs) #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_STACK. */ /* 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. */ #if defined (MATCH_MAY_ALLOCATE) int re_max_failures = 200000; #else int re_max_failures = 2000; #endif union fail_stack_elt { unsigned char *pointer; int integer; }; typedef union fail_stack_elt 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 macros to initialize and free the failure 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_STACK (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) #define RESET_FAIL_STACK() REGEX_FREE_STACK (fail_stack.stack) #else #define INIT_FAIL_STACK() \ do { \ fail_stack.avail = 0; \ } while (0) #define RESET_FAIL_STACK() #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_STACK 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_STACK ((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 pointer POINTER 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(POINTER, FAIL_STACK) \ ((FAIL_STACK_FULL () \ && !DOUBLE_FAIL_STACK (FAIL_STACK)) \ ? 0 \ : ((FAIL_STACK).stack[(FAIL_STACK).avail++].pointer = POINTER, \ 1)) /* Push a pointer value onto the failure stack. Assumes the variable `fail_stack'. Probably should only be called from within `PUSH_FAILURE_POINT'. */ #define PUSH_FAILURE_POINTER(item) \ fail_stack.stack[fail_stack.avail++].pointer = (unsigned char *) (item) /* This pushes an integer-valued item onto the failure stack. Assumes the variable `fail_stack'. Probably should only be called from within `PUSH_FAILURE_POINT'. */ #define PUSH_FAILURE_INT(item) \ fail_stack.stack[fail_stack.avail++].integer = (item) /* Push a fail_stack_elt_t value onto the failure stack. Assumes the variable `fail_stack'. Probably should only be called from within `PUSH_FAILURE_POINT'. */ #define PUSH_FAILURE_ELT(item) \ fail_stack.stack[fail_stack.avail++] = (item) /* These three POP... operations complement the three PUSH... operations. All assume that `fail_stack' is nonempty. */ #define POP_FAILURE_POINTER() fail_stack.stack[--fail_stack.avail].pointer #define POP_FAILURE_INT() fail_stack.stack[--fail_stack.avail].integer #define POP_FAILURE_ELT() 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_INT #define DEBUG_POP(item_addr) *(item_addr) = POP_FAILURE_INT () #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_POINTER (regstart[this_reg]); \ \ DEBUG_PRINT2 (" end: 0x%x\n", regend[this_reg]); \ PUSH_FAILURE_POINTER (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_ELT (reg_info[this_reg].word); \ } \ \ DEBUG_PRINT2 (" Pushing low active reg: %d\n", lowest_active_reg);\ PUSH_FAILURE_INT (lowest_active_reg); \ \ DEBUG_PRINT2 (" Pushing high active reg: %d\n", highest_active_reg);\ PUSH_FAILURE_INT (highest_active_reg); \ \ DEBUG_PRINT2 (" Pushing pattern 0x%x: ", pattern_place); \ DEBUG_PRINT_COMPILED_PATTERN (bufp, pattern_place, pend); \ PUSH_FAILURE_POINTER (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_POINTER (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_POINTER (); \ 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_POINTER (); \ DEBUG_PRINT2 (" Popping pattern 0x%x: ", pat); \ DEBUG_PRINT_COMPILED_PATTERN (bufp, pat, pend); \ \ /* Restore register info. */ \ high_reg = (unsigned) POP_FAILURE_INT (); \ DEBUG_PRINT2 (" Popping high active reg: %d\n", high_reg); \ \ low_reg = (unsigned) POP_FAILURE_INT (); \ 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_ELT (); \ DEBUG_PRINT2 (" info: 0x%x\n", reg_info[this_reg]); \ \ regend[this_reg] = (const char *) POP_FAILURE_POINTER (); \ DEBUG_PRINT2 (" end: 0x%x\n", regend[this_reg]); \ \ regstart[this_reg] = (const char *) POP_FAILURE_POINTER (); \ DEBUG_PRINT2 (" start: 0x%x\n", regstart[this_reg]); \ } \ \ set_regs_matched_done = 0; \ DEBUG_STATEMENT (nfailure_points_popped++); \ } /* POP_FAILURE_POINT */ /* Structure for per-register (a.k.a. per-group) information. 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 \ { \ if (!set_regs_matched_done) \ { \ unsigned r; \ set_regs_matched_done = 1; \ 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. */ static char reg_unset_dummy; #define REG_UNSET_VALUE (®_unset_dummy) #define REG_UNSET(e) ((e) == REG_UNSET_VALUE) /* 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")) #ifndef MATCH_MAY_ALLOCATE /* If we cannot allocate large objects within re_match_2_internal, we make the fail stack and register vectors global. The fail stack, we grow to the maximum size when a regexp is compiled. The register vectors, we adjust in size each time we compile a regexp, according to the number of registers it needs. */ static fail_stack_type fail_stack; /* Size with which the following vectors are currently allocated. That is so we can make them bigger as needed, but never make them smaller. */ static int regs_allocated_size; 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; /* Make the register vectors big enough for NUM_REGS registers, but don't make them smaller. */ static regex_grow_registers (num_regs) int num_regs; { if (num_regs > regs_allocated_size) { 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); regs_allocated_size = num_regs; } } #endif /* not MATCH_MAY_ALLOCATE */ /* `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. */ /* Return, freeing storage we allocated. */ #define FREE_STACK_RETURN(value) \ return (free (compile_stack.stack), value) 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++) putchar (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) FREE_STACK_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) FREE_STACK_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) FREE_STACK_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) FREE_STACK_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) FREE_STACK_RETURN (REG_EBRACK); PATFETCH (c); /* \ might escape characters inside [...] and [^...]. */ if ((syntax & RE_BACKSLASH_ESCAPE_IN_LISTS) && c == '\\') { if (p == pend) FREE_STACK_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 != ']') FREE_STACK_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) FREE_STACK_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) FREE_STACK_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) FREE_STACK_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)) FREE_STACK_RETURN (REG_ECTYPE); /* Throw away the ] at the end of the character class. */ PATFETCH (c); if (p == pend) FREE_STACK_RETURN (REG_EBRACK); for (ch = 0; ch < 1 << BYTEWIDTH; ch++) { /* This was split into 3 if's to avoid an arbitrary limit in some compiler. */ if ( (is_alnum && ISALNUM (ch)) || (is_alpha && ISALPHA (ch)) || (is_blank && ISBLANK (ch)) || (is_cntrl && ISCNTRL (ch))) SET_LIST_BIT (ch); if ( (is_digit && ISDIGIT (ch)) || (is_graph && ISGRAPH (ch)) || (is_lower && ISLOWER (ch)) || (is_print && ISPRINT (ch))) SET_LIST_BIT (ch); if ( (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) FREE_STACK_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 FREE_STACK_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 FREE_STACK_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 FREE_STACK_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 FREE_STACK_RETURN (REG_BADBR); } if (!(syntax & RE_NO_BK_BRACES)) { if (c != '\\') FREE_STACK_RETURN (REG_EBRACE); PATFETCH (c); } if (c != '}') { if (syntax & RE_NO_BK_BRACES) goto unfetch_interval; else FREE_STACK_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) FREE_STACK_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) FREE_STACK_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) FREE_STACK_RETURN (REG_EPAREN); /* If we don't want backtracking, force success the first time we reach the end of the compiled pattern. */ if (syntax & RE_NO_POSIX_BACKTRACKING) BUF_PUSH (succeed); 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 */ } regex_grow_registers (num_regs); } #endif /* not MATCH_MAY_ALLOCATE */ 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 : 0; 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. */ /* The SVR4 compiler on the 3B2 had trouble with unsigned const char *. */ range_start = ((const unsigned char *) p)[-2]; range_end = ((const 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; /* This holds the pointer to the failure stack, when it is allocated relocatably. */ fail_stack_elt_t *failure_stack_ptr; /* 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 (1) { if (p == pend || *p == succeed) { /* We have reached the (effective) end of pattern. */ if (!FAIL_STACK_EMPTY ()) { bufp->can_be_null |= path_can_be_null; /* Reset for next path. */ path_can_be_null = true; p = fail_stack.stack[--fail_stack.avail].pointer; continue; } else break; } /* We should never be about to go beyond the end of the pattern. */ assert (p < pend); switch (SWITCH_ENUM_CAST ((re_opcode_t) *p++)) { /* 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; goto done; /* 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: { int fastmap_newline = fastmap['\n']; /* `.' matches anything ... */ for (j = 0; j < (1 << BYTEWIDTH); j++) fastmap[j] = 1; /* ... except perhaps newline. */ if (!(bufp->syntax & RE_DOT_NEWLINE)) fastmap['\n'] = fastmap_newline; /* 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) goto done; /* 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].pointer == 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)) { RESET_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; done: RESET_FAIL_STACK (); 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 #define FREE_VAR(var) if (var) REGEX_FREE (var); var = NULL #define FREE_VARIABLES() \ do { \ REGEX_FREE_STACK (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 #define FREE_VARIABLES() ((void)0) /* Do nothing! But inhibit gcc warning. */ #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 /* This holds the pointer to the failure stack, when it is allocated relocatably. */ fail_stack_elt_t *failure_stack_ptr; /* 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; /* This helps SET_REGS_MATCHED avoid doing redundant work. */ int set_regs_matched_done = 0; /* 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; } } 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 /* 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) { /* 1 if this match ends in the same string (string1 or string2) as the best previous match. */ boolean same_str_p = (FIRST_STRING_P (match_end) == MATCHING_IN_FIRST_STRING); /* 1 if this match is the best seen so far. */ boolean best_match_p; /* AIX compiler got confused when this was combined with the previous declaration. */ if (same_str_p) best_match_p = d > match_end; else best_match_p = !MATCHING_IN_FIRST_STRING; DEBUG_PRINT1 ("backtracking.\n"); if (!FAIL_STACK_EMPTY ()) { /* More failure points to try. */ /* If exceeds best match so far, save it. */ if (!best_regs_set || best_match_p) { 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. And if last match is real best match, don't restore second best one. */ else if (best_regs_set && !best_match_p) { 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 */ succeed_label: 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) { FREE_VARIABLES (); 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) { FREE_VARIABLES (); 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 */ 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); FREE_VARIABLES (); return mcnt; } /* Otherwise match next pattern command. */ switch (SWITCH_ENUM_CAST ((re_opcode_t) *p++)) { /* 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; case succeed: DEBUG_PRINT1 ("EXECUTING succeed.\n"); goto succeed_label; /* 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; /* Clear this whenever we change the register activity status. */ set_regs_matched_done = 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; /* Clear this whenever we change the register activity status. */ set_regs_matched_done = 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 (old_regend[r] >= 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; /* Do this because we've match some characters. */ SET_REGS_MATCHED (); } } 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 && ! ((int) p2[1] * BYTEWIDTH > (int) 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 < (int) p2[1]; idx++) if (! (p2[2 + idx] == 0 || (idx < (int) 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 < (int) p2[1] && idx < (int) 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); if (!ret) return NULL; return gettext (re_error_msgid[(int) ret]); } /* Entry points compatible with 4.2 BSD regex library. We don't define them unless specifically requested. */ #ifdef _REGEX_RE_COMP /* 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 gettext ("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 gettext (re_error_msgid[(int) REG_ESPACE]); re_comp_buf.allocated = 200; re_comp_buf.fastmap = (char *) malloc (1 << BYTEWIDTH); if (re_comp_buf.fastmap == NULL) return gettext (re_error_msgid[(int) REG_ESPACE]); } /* 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); if (!ret) return NULL; /* Yes, we're discarding `const' here if !HAVE_LIBINTL. */ return (char *) gettext (re_error_msgid[(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 /* _REGEX_RE_COMP */ /* 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_msgid) / sizeof (re_error_msgid[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 = gettext (re_error_msgid[errcode]); 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: */ textutils-1.12/lib/error.c100444 12241 1 6265 5757202564 14536 0ustar rolanddaemon/* error.c -- error handler for noninteractive utilities Copyright (C) 1990, 91, 92, 93, 94, 95 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 #include #endif #include #if HAVE_VPRINTF || HAVE_DOPRNT # if __STDC__ # include # define VA_START(args, lastarg) va_start(args, lastarg) # else # include # define VA_START(args, lastarg) va_start(args) # endif #else # define va_alist a1, a2, a3, a4, a5, a6, a7, a8 # define va_dcl char *a1, *a2, *a3, *a4, *a5, *a6, *a7, *a8; #endif #if STDC_HEADERS # include # include #else void exit (); #endif /* This variable is incremented each time `error' is called. */ unsigned int error_message_count; /* If NULL, error will flush stdout, then print on stderr the program name, a colon and a space. Otherwise, error will call this function without parameters instead. */ void (*error_print_progname) () = NULL; /* The calling program should define program_name and set it to the name of the executing program. */ extern char *program_name; #if HAVE_STRERROR # ifndef strerror /* On some systems, sterror is a macro */ char *strerror (); # endif #else 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 /* 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(VA_START) && __STDC__ error (int status, int errnum, const char *message, ...) #else error (status, errnum, message, va_alist) int status; int errnum; char *message; va_dcl #endif { #ifdef VA_START va_list args; #endif if (error_print_progname) (*error_print_progname) (); else { fflush (stdout); fprintf (stderr, "%s: ", program_name); } #ifdef VA_START VA_START (args, message); # if HAVE_VPRINTF vfprintf (stderr, message, args); # else _doprnt (message, args, stderr); # endif va_end (args); #else fprintf (stderr, message, a1, a2, a3, a4, a5, a6, a7, a8); #endif ++error_message_count; if (errnum) fprintf (stderr, ": %s", strerror (errnum)); putc ('\n', stderr); fflush (stderr); if (status) exit (status); } textutils-1.12/lib/full-write.c100666 21570 13 3065 5733314506 14530 0ustar djmuser/* 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 #include #endif #include #ifdef HAVE_UNISTD_H #include #endif #include #ifndef errno 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; size_t 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; } textutils-1.12/lib/getopt.c100444 12241 1 53245 5734456756 14740 0ustar rolanddaemon/* 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, 95 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 #include #endif #if !defined (__STDC__) || !__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 is for other GNU distributions with internationalized messages. The GNU C Library itself does not yet support such messages. */ #if HAVE_LIBINTL_H # include #else # define gettext(msgid) (msgid) #endif /* 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; /* Value of POSIXLY_CORRECT environment variable. */ static char *posixly_correct; #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. */ #if !defined (__STDC__) || !__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; posixly_correct = getenv ("POSIXLY_CORRECT"); /* 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 (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); optind = 1; /* Don't scan ARGV[0], the program name. */ } 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, gettext ("%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, gettext ("%s: option `--%s' doesn't allow an argument\n"), argv[0], pfound->name); else /* +option or -option */ fprintf (stderr, gettext ("%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, gettext ("%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, gettext ("%s: unrecognized option `--%s'\n"), argv[0], nextchar); else /* +option or -option */ fprintf (stderr, gettext ("%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) { if (posixly_correct) /* 1003.2 specifies the format of this message. */ fprintf (stderr, gettext ("%s: illegal option -- %c\n"), argv[0], c); else fprintf (stderr, gettext ("%s: invalid 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, gettext ("%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 */ textutils-1.12/lib/getopt1.c100444 12241 1 10236 5655157105 14776 0ustar rolanddaemon/* getopt_long and getopt_long_only entry points for GNU getopt. Copyright (C) 1987, 88, 89, 90, 91, 92, 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, 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifdef HAVE_CONFIG_H #include #endif #include "getopt.h" #if !defined (__STDC__) || !__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 */ textutils-1.12/lib/linebuffer.c100666 74504 13 4542 5770311460 15627 0ustar meyeringuser/* linebuffer.c -- read arbitrarily long lines 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* Written by Richard Stallman. */ #ifdef HAVE_CONFIG_H #include #endif #include #include "linebuffer.h" char *xmalloc (); char *xrealloc (); void free (); /* Initialize linebuffer LINEBUFFER for use. */ void initbuffer (linebuffer) struct linebuffer *linebuffer; { linebuffer->length = 0; linebuffer->size = 200; linebuffer->buffer = (char *) xmalloc (linebuffer->size); } /* Read an arbitrarily long line of text from STREAM into LINEBUFFER. Remove any newline. Does not null terminate. Return LINEBUFFER, except at end of file return 0. */ struct linebuffer * readline (linebuffer, stream) struct linebuffer *linebuffer; FILE *stream; { int c; char *buffer = linebuffer->buffer; char *p = linebuffer->buffer; char *end = buffer + linebuffer->size; /* Sentinel. */ if (feof (stream)) { linebuffer->length = 0; return 0; } while (1) { c = getc (stream); if (p == end) { linebuffer->size *= 2; buffer = (char *) xrealloc (buffer, linebuffer->size); p += buffer - linebuffer->buffer; linebuffer->buffer = buffer; end = buffer + linebuffer->size; } if (c == EOF || c == '\n') break; *p++ = c; } if (feof (stream) && p == buffer) { linebuffer->length = 0; return 0; } linebuffer->length = p - linebuffer->buffer; return linebuffer; } /* Free linebuffer LINEBUFFER and its data, all allocated with malloc. */ void freebuffer (linebuffer) struct linebuffer *linebuffer; { free (linebuffer->buffer); free (linebuffer); } textutils-1.12/lib/long-options.c100644 74504 13 4023 5770034406 16126 0ustar meyeringuser/* 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 #include #endif #include #include #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, version_string, usage) int argc; char **argv; const char *command_name; const char *version_string; 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; } textutils-1.12/lib/memchr.c100666 74504 1 13724 5761752213 15252 0ustar meyeringdaemon/* Copyright (C) 1991, 1993 Free Software Foundation, Inc. Based on strlen implemention by Torbjorn Granlund (tege@sics.se), with help from Dan Sahlin (dan@sics.se) and commentary by Jim Blandy (jimb@ai.mit.edu); adaptation to memchr suggested by Dick Karpinski (dick@cca.ucsf.edu), and implemented by Roland McGrath (roland@ai.mit.edu). NOTE: The canonical source of this file is maintained with the GNU C Library. Bugs can be reported to bug-glibc@prep.ai.mit.edu. 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 #include #endif #undef __ptr_t #if defined (__cplusplus) || (defined (__STDC__) && __STDC__) # define __ptr_t void * #else /* Not C++ or ANSI C. */ # define __ptr_t char * #endif /* C++ or ANSI C. */ #if defined (_LIBC) # include #endif #if defined (HAVE_LIMITS_H) || defined (_LIBC) # include #endif #define LONG_MAX_32_BITS 2147483647 #ifndef LONG_MAX #define LONG_MAX LONG_MAX_32_BITS #endif #include /* Search no more than N bytes of S for C. */ __ptr_t memchr (s, c, n) const __ptr_t s; int c; size_t n; { const unsigned char *char_ptr; const unsigned long int *longword_ptr; unsigned long int longword, magic_bits, charmask; c = (unsigned char) c; /* Handle the first few characters by reading one character at a time. Do this until CHAR_PTR is aligned on a longword boundary. */ for (char_ptr = (const unsigned char *) s; n > 0 && ((unsigned long int) char_ptr & (sizeof (longword) - 1)) != 0; --n, ++char_ptr) if (*char_ptr == c) return (__ptr_t) char_ptr; /* All these elucidatory comments refer to 4-byte longwords, but the theory applies equally well to 8-byte longwords. */ longword_ptr = (unsigned long int *) char_ptr; /* Bits 31, 24, 16, and 8 of this number are zero. Call these bits the "holes." Note that there is a hole just to the left of each byte, with an extra at the end: bits: 01111110 11111110 11111110 11111111 bytes: AAAAAAAA BBBBBBBB CCCCCCCC DDDDDDDD The 1-bits make sure that carries propagate to the next 0-bit. The 0-bits provide holes for carries to fall into. */ if (sizeof (longword) != 4 && sizeof (longword) != 8) abort (); #if LONG_MAX <= LONG_MAX_32_BITS magic_bits = 0x7efefeff; #else magic_bits = ((unsigned long int) 0x7efefefe << 32) | 0xfefefeff; #endif /* Set up a longword, each of whose bytes is C. */ charmask = c | (c << 8); charmask |= charmask << 16; #if LONG_MAX > LONG_MAX_32_BITS charmask |= charmask << 32; #endif /* Instead of the traditional loop which tests each character, we will test a longword at a time. The tricky part is testing if *any of the four* bytes in the longword in question are zero. */ while (n >= sizeof (longword)) { /* We tentatively exit the loop if adding MAGIC_BITS to LONGWORD fails to change any of the hole bits of LONGWORD. 1) Is this safe? Will it catch all the zero bytes? Suppose there is a byte with all zeros. Any carry bits propagating from its left will fall into the hole at its least significant bit and stop. Since there will be no carry from its most significant bit, the LSB of the byte to the left will be unchanged, and the zero will be detected. 2) Is this worthwhile? Will it ignore everything except zero bytes? Suppose every byte of LONGWORD has a bit set somewhere. There will be a carry into bit 8. If bit 8 is set, this will carry into bit 16. If bit 8 is clear, one of bits 9-15 must be set, so there will be a carry into bit 16. Similarly, there will be a carry into bit 24. If one of bits 24-30 is set, there will be a carry into bit 31, so all of the hole bits will be changed. The one misfire occurs when bits 24-30 are clear and bit 31 is set; in this case, the hole at bit 31 is not changed. If we had access to the processor carry flag, we could close this loophole by putting the fourth hole at bit 32! So it ignores everything except 128's, when they're aligned properly. 3) But wait! Aren't we looking for C, not zero? Good point. So what we do is XOR LONGWORD with a longword, each of whose bytes is C. This turns each byte that is C into a zero. */ longword = *longword_ptr++ ^ charmask; /* Add MAGIC_BITS to LONGWORD. */ if ((((longword + magic_bits) /* Set those bits that were unchanged by the addition. */ ^ ~longword) /* Look at only the hole bits. If any of the hole bits are unchanged, most likely one of the bytes was a zero. */ & ~magic_bits) != 0) { /* Which of the bytes was C? If none of them were, it was a misfire; continue the search. */ const unsigned char *cp = (const unsigned char *) (longword_ptr - 1); if (cp[0] == c) return (__ptr_t) cp; if (cp[1] == c) return (__ptr_t) &cp[1]; if (cp[2] == c) return (__ptr_t) &cp[2]; if (cp[3] == c) return (__ptr_t) &cp[3]; #if LONG_MAX > 2147483647 if (cp[4] == c) return (__ptr_t) &cp[4]; if (cp[5] == c) return (__ptr_t) &cp[5]; if (cp[6] == c) return (__ptr_t) &cp[6]; if (cp[7] == c) return (__ptr_t) &cp[7]; #endif } n -= sizeof (longword); } char_ptr = (const unsigned char *) longword_ptr; while (n-- > 0) { if (*char_ptr == c) return (__ptr_t) char_ptr; else ++char_ptr; } return 0; } textutils-1.12/lib/safe-read.c100666 74504 13 2711 5770311463 15334 0ustar meyeringuser/* safe-read.c -- an interface to read 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #ifdef HAVE_CONFIG_H #include #endif #include #ifdef HAVE_UNISTD_H #include #endif #include #ifndef errno extern int errno; #endif /* Read LEN bytes at PTR from descriptor DESC, retrying if interrupted. Return the actual number of bytes read, zero for EOF, or negative for an error. */ int safe_read (desc, ptr, len) int desc; char *ptr; int len; { int n_chars; if (len <= 0) return len; #ifdef EINTR do { n_chars = read (desc, ptr, len); } while (n_chars < 0 && errno == EINTR); #else n_chars = read (desc, ptr, len); #endif return n_chars; } textutils-1.12/lib/xmalloc.c100444 74720 1 4372 5666652252 15053 0ustar eggertdaemon/* xmalloc.c -- malloc with out of memory checking Copyright (C) 1990, 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, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifdef HAVE_CONFIG_H #include #endif #if __STDC__ #define VOID void #else #define VOID char #endif #include #if STDC_HEADERS #include #else VOID *malloc (); VOID *realloc (); void free (); #endif /* This is for other GNU distributions with internationalized messages. The GNU C Library itself does not yet support such messages. */ #if HAVE_LIBINTL_H # include #else # define gettext(msgid) (msgid) #endif #ifndef EXIT_FAILURE #define EXIT_FAILURE 1 #endif /* Exit value when the requested amount of memory is not available. The caller may set it to some other value. */ int xmalloc_exit_failure = EXIT_FAILURE; #if __STDC__ && (HAVE_VPRINTF || HAVE_DOPRNT) void error (int, int, const char *, ...); #else void error (); #endif static VOID * fixup_null_alloc (n) size_t n; { VOID *p; p = 0; if (n == 0) p = malloc ((size_t) 1); if (p == 0) error (xmalloc_exit_failure, 0, gettext ("Memory exhausted")); return p; } /* Allocate N bytes of memory dynamically, with error checking. */ VOID * xmalloc (n) size_t n; { VOID *p; p = malloc (n); if (p == 0) p = fixup_null_alloc (n); return p; } /* Change the size of an allocated block of memory P to N bytes, with error checking. If P is NULL, run xmalloc. */ VOID * xrealloc (p, n) VOID *p; size_t n; { if (p == 0) return xmalloc (n); p = realloc (p, n); if (p == 0) p = fixup_null_alloc (n); return p; } textutils-1.12/lib/alloca.c100444 21570 1 33405 5641641234 14145 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 #include #endif #ifdef emacs #include "blockinput.h" #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. */ #ifdef emacs BLOCK_INPUT; #endif 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. */ #ifdef emacs UNBLOCK_INPUT; #endif } 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 */ textutils-1.12/lib/bcopy.c100444 21570 13 1065 5232060361 13531 0ustar djmuser/* bcopy.c -- copy memory. Copy LENGTH bytes from SOURCE to DEST. Does not null-terminate. In the public domain. By David MacKenzie . */ void bcopy (source, dest, length) char *source, *dest; unsigned length; { if (source < dest) /* Moving from low mem to hi mem; start at end. */ for (source += length, dest += length; length; --length) *--dest = *--source; else if (source != dest) /* Moving from hi mem to low mem; start at beginning. */ for (; length; --length) *dest++ = *source++; } textutils-1.12/lib/memcmp.c100666 74504 1 21130 5730214633 15236 0ustar meyeringdaemon/* Copyright (C) 1991, 1993, 1995 Free Software Foundation, Inc. Contributed by Torbjorn Granlund (tege@sics.se). NOTE: The canonical source of this file is maintained with the GNU C Library. Bugs can be reported to bug-glibc@prep.ai.mit.edu. 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 #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. */ #ifdef WORDS_BIGENDIAN #define CMP_LT_OR_GT(a, b) ((a) > (b) ? 1 : -1) #else #define CMP_LT_OR_GT(a, b) memcmp_bytes ((a), (b)) #endif /* 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) return CMP_LT_OR_GT (a1, b1); do3: a1 = ((op_t *) srcp1)[1]; b1 = ((op_t *) srcp2)[1]; if (a0 != b0) return CMP_LT_OR_GT (a0, b0); do2: a0 = ((op_t *) srcp1)[2]; b0 = ((op_t *) srcp2)[2]; if (a1 != b1) return CMP_LT_OR_GT (a1, b1); do1: a1 = ((op_t *) srcp1)[3]; b1 = ((op_t *) srcp2)[3]; if (a0 != b0) return CMP_LT_OR_GT (a0, b0); 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) return CMP_LT_OR_GT (a1, b1); 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) return CMP_LT_OR_GT (x, b3); do3: a1 = ((op_t *) srcp1)[1]; b1 = ((op_t *) srcp2)[1]; x = MERGE(a3, shl, a0, shr); if (x != b0) return CMP_LT_OR_GT (x, b0); do2: a2 = ((op_t *) srcp1)[2]; b2 = ((op_t *) srcp2)[2]; x = MERGE(a0, shl, a1, shr); if (x != b1) return CMP_LT_OR_GT (x, b1); do1: a3 = ((op_t *) srcp1)[3]; b3 = ((op_t *) srcp2)[3]; x = MERGE(a1, shl, a2, shr); if (x != b2) return CMP_LT_OR_GT (x, b2); 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) return CMP_LT_OR_GT (x, b3); 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; } #ifdef weak_alias #undef bcmp weak_alias (memcmp, bcmp) #endif textutils-1.12/lib/memcpy.c100644 74504 13 1111 5712445315 14764 0ustar meyeringuser/* memcpy.c -- copy memory. Copy LENGTH bytes from SOURCE to DEST. Does not null-terminate. The source and destination regions may not overlap. In the public domain. By Jim Meyering. */ /* FIXME: remove this before release. */ #include #ifndef ABS # define ABS(x) ((x) < 0 ? (-(x)) : (x)) #endif void memcpy (dest, source, length) char *dest; const char *source; unsigned length; { assert (length >= 0); /* Make sure they don't overlap. */ assert (ABS (dest - source) >= length); for (; length; --length) *dest++ = *source++; } textutils-1.12/lib/memmove.c100644 74504 13 1172 5757521461 15154 0ustar meyeringuser/* memmove.c -- copy memory. Copy LENGTH bytes from SOURCE to DEST. Does not null-terminate. In the public domain. By David MacKenzie . */ #ifdef HAVE_CONFIG_H #include #endif void memmove (dest, source, length) char *dest; const char *source; unsigned length; { if (source < dest) /* Moving from low mem to hi mem; start at end. */ for (source += length, dest += length; length; --length) *--dest = *--source; else if (source != dest) /* Moving from hi mem to low mem; start at beginning. */ for (; length; --length) *dest++ = *source++; } textutils-1.12/lib/memset.c100444 21570 1 1663 5050603657 14166 0ustar djmdaemon/* memset.c -- set an area of memory to a given value 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. */ char * memset (str, c, len) char *str; int c; unsigned len; { register char *st = str; while (len-- > 0) *st++ = c; return str; } textutils-1.12/lib/stpcpy.c100444 74504 1 2111 5650475202 15254 0ustar meyeringdaemon/* stpcpy.c -- copy a string and return pointer to end of new string Copyright (C) 1989, 1990 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. */ #ifdef HAVE_CONFIG_H #include #endif /* Copy SRC to DEST, returning the address of the terminating '\0' in DEST. */ char * stpcpy (dest, src) char *dest; const char *src; { while ((*dest++ = *src++) != '\0') /* Do nothing. */ ; return dest - 1; } textutils-1.12/lib/strtol.c100444 74504 1 7674 5712202341 15273 0ustar meyeringdaemon/* Copyright (C) 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. */ #ifdef HAVE_CONFIG_H #include #endif #include #include #ifndef errno extern int errno; #endif #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 #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; } textutils-1.12/lib/strtoul.c100666 74504 1 1544 5757554457 15507 0ustar meyeringdaemon/* Copyright (C) 1991 Free Software Foundation, Inc. NOTE: The canonical source of this file is maintained with the GNU C Library. Bugs can be reported to bug-glibc@prep.ai.mit.edu. 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. */ #define UNSIGNED 1 #include textutils-1.12/lib/xstrtol.c100644 74504 13 4633 5760537532 15233 0ustar meyeringuser#ifdef HAVE_CONFIG_H #include #endif #ifdef STDC_HEADERS #include #endif #ifdef HAVE_STRING_H # include #else # include # ifndef strchr # define strchr index # endif #endif #define NDEBUG #include #include #ifndef errno extern int errno; #endif #if HAVE_LIMITS_H #include #endif #ifndef ULONG_MAX #define ULONG_MAX ((unsigned long) ~(unsigned long) 0) #endif #ifndef LONG_MAX #define LONG_MAX ((long int) (ULONG_MAX >> 1)) #endif #include "xstrtol.h" #define BKM_SCALE(x, scale_factor, error_return) \ do \ { \ if ((x) > (double) __ZLONG_MAX / (scale_factor)) \ return (error_return); \ (x) *= (scale_factor); \ } \ while (0) __unsigned long int __strtol (); /* FIXME: comment. */ strtol_error __xstrtol (s, ptr, base, val, valid_suffixes) const char *s; char **ptr; int base; __unsigned long int *val; const char *valid_suffixes; { char *t_ptr; char **p; __unsigned long int tmp; assert (0 <= base && base <= 36); p = (ptr ? ptr : &t_ptr); errno = 0; tmp = __strtol (s, p, base); if (errno != 0) return LONGINT_OVERFLOW; if (*p == s) return LONGINT_INVALID; if (!valid_suffixes) { if (**p == '\0') { *val = tmp; return LONGINT_OK; } else return LONGINT_INVALID_SUFFIX_CHAR; } if (**p != '\0' && strchr (valid_suffixes, **p)) { switch (**p) { case 'b': BKM_SCALE (tmp, 512, LONGINT_OVERFLOW); ++(*p); break; case 'c': ++(*p); break; case 'B': case 'k': BKM_SCALE (tmp, 1024, LONGINT_OVERFLOW); ++(*p); break; case 'm': BKM_SCALE (tmp, 1024 * 1024, LONGINT_OVERFLOW); ++(*p); break; case 'w': BKM_SCALE (tmp, 2, LONGINT_OVERFLOW); ++(*p); break; default: return LONGINT_INVALID_SUFFIX_CHAR; break; } } *val = tmp; return LONGINT_OK; } #ifdef TESTING_XSTRTO #include #include "error.h" char *program_name; int main (int argc, char** argv) { strtol_error s_err; int i; program_name = argv[0]; for (i=1; i%lu (%s)\n", argv[i], val, p); } else { STRTOL_FATAL_ERROR (argv[i], "arg", s_err); } } exit (0); } #endif /* TESTING_XSTRTO */ textutils-1.12/lib/xstrtoul.c100644 74504 13 62 5667263746 15361 0ustar meyeringuser#define STRING_TO_UNSIGNED 1 #include "xstrtol.c" textutils-1.12/src/ 40777 74504 13 0 5771033561 13265 5ustar meyeringusertextutils-1.12/src/Makefile.in100666 74504 13 12516 5770310716 15453 0ustar meyeringuser# Makefile for GNU text 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. SHELL = /bin/sh srcdir = @srcdir@ VPATH = @srcdir@ prefix = @prefix@ exec_prefix = @exec_prefix@ bindir = $(exec_prefix)/bin libdir = $(exec_prefix)/lib INSTALL = @INSTALL@ INSTALL_PROGRAM = @INSTALL_PROGRAM@ CC = @CC@ DEFS = @DEFS@ LIBS = @LIBS@ CFLAGS = @CFLAGS@ LDFLAGS = @LDFLAGS@ RM = rm LN = ln MV = mv SOURCES = cat.c cksum.c comm.c csplit.c cut.c expand.c fmt.c fold.c \ head.c join.c md5sum.c nl.c od.c paste.c pr.c sort.c split.c sum.c tac.c \ tail.c tr.c unexpand.c uniq.c wc.c version.c OBJECTS = cat.o cksum.o comm.o csplit.o cut.o expand.o fmt.o fold.o \ head.o join.o md5sum.o nl.o od.o paste.o pr.o sort.o split.o sum.o tac.o \ tail.o tr.o unexpand.o uniq.o wc.o version.o DISTFILES = Makefile.in system.h version.h md5-test.rfc $(SOURCES) PROGS = cat cksum comm csplit cut expand fmt fold head join md5sum nl od \ paste pr sort split sum tac tail tr unexpand uniq wc LIBPROGS = all: $(PROGS) $(LIBPROGS) .SUFFIXES: .SUFFIXES: .c .o incl = -I.. -I$(srcdir) -I../lib -I$(srcdir)/../lib .c.o: $(CC) -c $(CPPFLAGS) $(DEFS) $(incl) $(CFLAGS) $< subdir = src Makefile: ../config.status Makefile.in cd .. && CONFIG_FILES=$(subdir)/$@ CONFIG_HEADERS= ./config.status installdirs: $(srcdir)/../mkinstalldirs $(bindir) transform = @program_transform_name@ install: install-exec install-data install-data: install-exec: all installdirs for f in $(PROGS); do \ $(INSTALL_PROGRAM) $$f \ $(bindir)/`echo $$f|sed '$(transform)'`; \ done uninstall: for f in $(PROGS); do \ $(RM) -f \ $(bindir)/`echo $$f|sed '$(transform)'`; \ done TAGS: $(SOURCES) etags $(SOURCES) check: md5sum ./md5sum \ --string="" \ --string="a" \ --string="abc" \ --string="message digest" \ --string="abcdefghijklmnopqrstuvwxyz" \ --string="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" \ --string="12345678901234567890123456789012345678901234567890123456789012345678901234567890" \ | diff -c $(srcdir)/md5-test.rfc - clean: $(RM) -f $(PROGS) $(LIBPROGS) *.o core mostlyclean: clean distclean: clean $(RM) -f Makefile maintainer-clean: distclean $(RM) -f TAGS distdir = ../`cat ../distname`/$(subdir) dist: $(DISTFILES) for file in $(DISTFILES); do \ $(LN) $$file $(distdir) \ || { echo copying $$file instead; cp -p $$file $(distdir);}; \ done # Linking rules. link_command = $(CC) $(LDFLAGS) -o $@ cat: cat.o $(link_command) cat.o ../lib/libtu.a version.o $(LIBS) cksum: cksum.o $(link_command) cksum.o ../lib/libtu.a version.o $(LIBS) comm: comm.o $(link_command) comm.o ../lib/libtu.a version.o $(LIBS) csplit: csplit.o $(link_command) csplit.o ../lib/libtu.a version.o $(LIBS) cut: cut.o $(link_command) cut.o ../lib/libtu.a version.o $(LIBS) expand: expand.o $(link_command) expand.o ../lib/libtu.a version.o $(LIBS) fmt: fmt.o $(link_command) fmt.o ../lib/libtu.a version.o $(LIBS) fold: fold.o $(link_command) fold.o ../lib/libtu.a version.o $(LIBS) head: head.o $(link_command) head.o ../lib/libtu.a version.o $(LIBS) join: join.o $(link_command) join.o ../lib/libtu.a version.o $(LIBS) md5sum: md5sum.o $(link_command) md5sum.o ../lib/libtu.a version.o $(LIBS) nl: nl.o $(link_command) nl.o ../lib/libtu.a version.o $(LIBS) od: od.o $(link_command) od.o ../lib/libtu.a version.o $(LIBS) paste: paste.o $(link_command) paste.o ../lib/libtu.a version.o $(LIBS) pr: pr.o $(link_command) pr.o ../lib/libtu.a version.o $(LIBS) sort: sort.o $(link_command) sort.o ../lib/libtu.a version.o $(LIBS) split: split.o $(link_command) split.o ../lib/libtu.a version.o $(LIBS) sum: sum.o $(link_command) sum.o ../lib/libtu.a version.o $(LIBS) tac: tac.o $(link_command) tac.o ../lib/libtu.a version.o $(LIBS) tail: tail.o $(link_command) tail.o ../lib/libtu.a version.o $(LIBS) tr: tr.o $(link_command) tr.o ../lib/libtu.a version.o $(LIBS) unexpand: unexpand.o $(link_command) unexpand.o ../lib/libtu.a version.o $(LIBS) uniq: uniq.o $(link_command) uniq.o ../lib/libtu.a version.o $(LIBS) wc: wc.o $(link_command) wc.o ../lib/libtu.a version.o $(LIBS) $(PROGS) $(LIBPROGS): ../lib/libtu.a version.o csplit.o nl.o tac.o: ../lib/regex.h comm.o nl.o uniq.o: ../lib/linebuffer.h od.o tail.o: ../lib/xstrtol.h # Make all .o files depend on these files even though there are a few # unnecessary dependencies. $(OBJECTS): ../config.h ../lib/error.h system.h version.h .PHONY: all check clean dist distclean install install-data install-exec \ installdirs maintainer-clean mostlyclean uninstall # 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: textutils-1.12/src/system.h100666 74504 13 11143 5770310710 15070 0ustar meyeringuser/* system-dependent definitions for textutils programs. 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* Include sys/types.h before this file. */ #include #ifdef STAT_MACROS_BROKEN #undef S_ISBLK #undef S_ISCHR #undef S_ISDIR #undef S_ISFIFO #undef S_ISLNK #undef S_ISMPB #undef S_ISMPC #undef S_ISNWK #undef S_ISREG #undef S_ISSOCK #endif /* STAT_MACROS_BROKEN. */ #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 #if !defined(HAVE_MKFIFO) #define mkfifo(path, mode) (mknod ((path), (mode) | S_IFIFO, 0)) #endif #ifdef HAVE_UNISTD_H #include #endif #ifndef _POSIX_VERSION off_t lseek (); #endif #ifndef STDIN_FILENO #define STDIN_FILENO 0 #endif #ifndef STDOUT_FILENO #define STDOUT_FILENO 1 #endif #ifndef STDERR_FILENO #define STDERR_FILENO 2 #endif /* Don't use bcopy! Use memmove if source and destination may overlap, memcpy otherwise. */ #ifdef HAVE_STRING_H # if !STDC_HEADERS && HAVE_MEMORY_H # include # endif # include #else # include char *memchr (); #endif #include #ifndef errno extern int errno; #endif #ifdef STDC_HEADERS #include #else char *getenv (); #endif #ifdef HAVE_FCNTL_H #include #else #include #endif #if !defined(SEEK_SET) #define SEEK_SET 0 #define SEEK_CUR 1 #define SEEK_END 2 #endif #ifndef _POSIX_SOURCE #include #endif /* Get or fake the disk device blocksize. Usually defined by sys/param.h (if at all). */ #if !defined(DEV_BSIZE) && defined(BSIZE) #define DEV_BSIZE BSIZE #endif #if !defined(DEV_BSIZE) && defined(BBSIZE) /* SGI */ #define DEV_BSIZE BBSIZE #endif #ifndef DEV_BSIZE #define DEV_BSIZE 4096 #endif /* Extract or fake data from a `struct stat'. ST_BLKSIZE: Optimal I/O blocksize for the file, in bytes. */ #ifndef HAVE_ST_BLKSIZE # define ST_BLKSIZE(statbuf) DEV_BSIZE #else /* HAVE_ST_BLKSIZE */ /* Some systems, like Sequents, return st_blksize of 0 on pipes. */ # define ST_BLKSIZE(statbuf) ((statbuf).st_blksize > 0 \ ? (statbuf).st_blksize : DEV_BSIZE) #endif /* HAVE_ST_BLKSIZE */ #ifndef S_ISLNK #define lstat stat #endif #ifndef RETSIGTYPE #define RETSIGTYPE void #endif #include #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)) textutils-1.12/src/version.h100644 74504 13 43 5370552316 15150 0ustar meyeringuserextern const char *version_string; textutils-1.12/src/md5-test.rfc100644 74504 13 704 5770035020 15464 0ustar meyeringuserd41d8cd98f00b204e9800998ecf8427e b "" 0cc175b9c0f1b6a831c399e269772661 b "a" 900150983cd24fb0d6963f7d28e17f72 b "abc" f96b697d7cb7938d525a2f31aaf161d0 b "message digest" c3fcd3d76192e4007dfb496cca67e13b b "abcdefghijklmnopqrstuvwxyz" d174ab98d277d9f5a5611c2c9f419d9f b "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" 57edf4a22be3c955ac49da2e2107b67a b "12345678901234567890123456789012345678901234567890123456789012345678901234567890" textutils-1.12/src/cat.c100666 74504 13 42144 5770310501 14311 0ustar meyeringuser/* cat -- concatenate files and print on the standard output. Copyright (C) 1988, 1990, 1991, 1995 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* Differences from the Unix cat: * Always unbuffered, -u is ignored. * 100 times faster with -v -u. * 20 times faster with -v. By tege@sics.se, Torbjorn Granlund, advised by rms, Richard Stallman. */ #include #include #include #include #ifndef _POSIX_SOURCE #include #endif #include "system.h" #include "version.h" #include "error.h" #define max(h,i) ((h) > (i) ? (h) : (i)) char *stpcpy (); char *xmalloc (); int full_write (); int safe_read (); static void cat (); static void next_line_num (); static void simple_cat (); /* Name under which this program was invoked. */ char *program_name; /* Name of input file. May be "-". */ static char *infile; /* Descriptor on which input file is open. */ static int input_desc; /* Descriptor on which output file is open. Always is 1. */ static int output_desc; /* Buffer for line numbers. */ static char line_buf[13] = {' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '0', '\t', '\0'}; /* Position in `line_buf' where printing starts. This will not change unless the number of lines is larger than 999999. */ static char *line_num_print = line_buf + 5; /* Position of the first digit in `line_buf'. */ static char *line_num_start = line_buf + 10; /* Position of the last digit in `line_buf'. */ static char *line_num_end = line_buf + 10; /* Preserves the `cat' function's local `newlines' between invocations. */ static int newlines2 = 0; /* Count of non-fatal error conditions. */ static int exit_stat = 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 ("\ Concatenate FILE(s), or standard input, to standard output.\n\ \n\ -b, --number-nonblank number nonblank output lines\n\ -e equivalent to -vE\n\ -n, --number number all output lines\n\ -s, --squeeze-blank never more than one single blank line\n\ -t equivalent to -vT\n\ -u (ignored)\n\ -v, --show-nonprinting use ^ and M- notation, save for LFD and TAB\n\ -A, --show-all equivalent to -vET\n\ -E, --show-ends display $ at end of each line\n\ -T, --show-tabs display TAB characters as ^I\n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ With no FILE, or when FILE is -, read standard input.\n\ "); } exit (status); } void main (argc, argv) int argc; char *argv[]; { /* Optimal size of i/o operations of output. */ int outsize; /* Optimal size of i/o operations of input. */ int insize; /* Pointer to the input buffer. */ unsigned char *inbuf; /* Pointer to the output buffer. */ unsigned char *outbuf; int c; /* Index in argv to processed argument. */ int argind; /* Device number of the output (file or whatever). */ int out_dev; /* I-node number of the output. */ int out_ino; /* Nonzero if the output file should not be the same as any input file. */ int check_redirection = 1; /* Nonzero if we have ever read standard input. */ int have_read_stdin = 0; struct stat stat_buf; /* Variables that are set according to the specified options. */ int numbers = 0; int numbers_at_empty_lines = 1; int squeeze_empty_lines = 0; int mark_line_ends = 0; int quote = 0; int output_tabs = 1; /* If non-zero, call cat, otherwise call simple_cat to do the actual work. */ int options = 0; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output then exit. */ static int show_version; static struct option const long_options[] = { {"number-nonblank", no_argument, NULL, 'b'}, {"number", no_argument, NULL, 'n'}, {"squeeze-blank", no_argument, NULL, 's'}, {"show-nonprinting", no_argument, NULL, 'v'}, {"show-ends", no_argument, NULL, 'E'}, {"show-tabs", no_argument, NULL, 'T'}, {"show-all", no_argument, NULL, 'A'}, {"help", no_argument, &show_help, 1}, {"version", no_argument, &show_version, 1}, {NULL, 0, NULL, 0} }; program_name = argv[0]; /* Parse command line options. */ while ((c = getopt_long (argc, argv, "benstuvAET", long_options, (int *) 0)) != EOF) { switch (c) { case 0: break; case 'b': ++options; numbers = 1; numbers_at_empty_lines = 0; break; case 'e': ++options; mark_line_ends = 1; quote = 1; break; case 'n': ++options; numbers = 1; break; case 's': ++options; squeeze_empty_lines = 1; break; case 't': ++options; output_tabs = 0; quote = 1; break; case 'u': /* We provide the -u feature unconditionally. */ break; case 'v': ++options; quote = 1; break; case 'A': ++options; quote = 1; mark_line_ends = 1; output_tabs = 0; break; case 'E': ++options; mark_line_ends = 1; break; case 'T': ++options; output_tabs = 0; break; default: usage (2); } } if (show_version) { printf ("cat - %s\n", version_string); exit (0); } if (show_help) usage (0); output_desc = 1; /* Get device, i-node number, and optimal blocksize of output. */ if (fstat (output_desc, &stat_buf) < 0) error (1, errno, "standard output"); outsize = ST_BLKSIZE (stat_buf); /* Input file can be output file for non-regular files. fstat on pipes returns S_IFSOCK on some systems, S_IFIFO on others, so the checking should not be done for those types, and to allow things like cat < /dev/tty > /dev/tty, checking is not done for device files either. */ if (S_ISREG (stat_buf.st_mode)) { out_dev = stat_buf.st_dev; out_ino = stat_buf.st_ino; } else { check_redirection = 0; #ifdef lint /* Suppress `used before initialized' warning. */ out_dev = 0; out_ino = 0; #endif } /* Check if any of the input files are the same as the output file. */ /* Main loop. */ infile = "-"; argind = optind; do { if (argind < argc) infile = argv[argind]; if (infile[0] == '-' && infile[1] == 0) { have_read_stdin = 1; input_desc = 0; } else { input_desc = open (infile, O_RDONLY); if (input_desc < 0) { error (0, errno, "%s", infile); exit_stat = 1; continue; } } if (fstat (input_desc, &stat_buf) < 0) { error (0, errno, "%s", infile); exit_stat = 1; goto contin; } insize = ST_BLKSIZE (stat_buf); /* Compare the device and i-node numbers of this input file with the corresponding values of the (output file associated with) stdout, and skip this input file if they coincide. Input files cannot be redirected to themselves. */ if (check_redirection && stat_buf.st_dev == out_dev && stat_buf.st_ino == out_ino) { error (0, 0, "%s: input file is output file", infile); exit_stat = 1; goto contin; } /* Select which version of `cat' to use. If any options (more than -u, --version, or --help) were specified, use `cat', otherwise use `simple_cat'. */ if (options == 0) { insize = max (insize, outsize); inbuf = (unsigned char *) xmalloc (insize); simple_cat (inbuf, insize); } else { inbuf = (unsigned char *) xmalloc (insize + 1); /* Why are (OUTSIZE - 1 + INSIZE * 4 + 13) bytes allocated for the output buffer? A test whether output needs to be written is done when the input buffer empties or when a newline appears in the input. After output is written, at most (OUTSIZE - 1) bytes will remain in the buffer. Now INSIZE bytes of input is read. Each input character may grow by a factor of 4 (by the prepending of M-^). If all characters do, and no newlines appear in this block of input, we will have at most (OUTSIZE - 1 + INSIZE) bytes in the buffer. If the last character in the preceding block of input was a newline, a line number may be written (according to the given options) as the first thing in the output buffer. (Done after the new input is read, but before processing of the input begins.) A line number requires seldom more than 13 positions. */ outbuf = (unsigned char *) xmalloc (outsize - 1 + insize * 4 + 13); cat (inbuf, insize, outbuf, outsize, quote, output_tabs, numbers, numbers_at_empty_lines, mark_line_ends, squeeze_empty_lines); free (outbuf); } free (inbuf); contin: if (strcmp (infile, "-") && close (input_desc) < 0) { error (0, errno, "%s", infile); exit_stat = 1; } } while (++argind < argc); if (have_read_stdin && close (0) < 0) error (1, errno, "-"); if (close (1) < 0) error (1, errno, "write error"); exit (exit_stat); } /* Plain cat. Copies the file behind `input_desc' to the file behind `output_desc'. */ static void simple_cat (buf, bufsize) /* Pointer to the buffer, used by reads and writes. */ unsigned char *buf; /* Number of characters preferably read or written by each read and write call. */ int bufsize; { /* Actual number of characters read, and therefore written. */ int n_read; /* Loop until the end of the file. */ for (;;) { /* Read a block of input. */ n_read = safe_read (input_desc, buf, bufsize); if (n_read < 0) { error (0, errno, "%s", infile); exit_stat = 1; return; } /* End of this file? */ if (n_read == 0) break; /* Write this block out. */ if (full_write (output_desc, buf, n_read) < 0) error (1, errno, "write error"); } } /* Cat the file behind INPUT_DESC to the file behind OUTPUT_DESC. Called if any option more than -u was specified. A newline character is always put at the end of the buffer, to make an explicit test for buffer end unnecessary. */ static void cat (inbuf, insize, outbuf, outsize, quote, output_tabs, numbers, numbers_at_empty_lines, mark_line_ends, squeeze_empty_lines) /* Pointer to the beginning of the input buffer. */ unsigned char *inbuf; /* Number of characters read in each read call. */ int insize; /* Pointer to the beginning of the output buffer. */ unsigned char *outbuf; /* Number of characters written by each write call. */ int outsize; /* Variables that have values according to the specified options. */ int quote; int output_tabs; int numbers; int numbers_at_empty_lines; int mark_line_ends; int squeeze_empty_lines; { /* Last character read from the input buffer. */ unsigned char ch; /* Pointer to the next character in the input buffer. */ unsigned char *bpin; /* Pointer to the first non-valid byte in the input buffer, i.e. the current end of the buffer. */ unsigned char *eob; /* Pointer to the position where the next character shall be written. */ unsigned char *bpout; /* Number of characters read by the last read call. */ int n_read; /* Determines how many consecutive newlines there have been in the input. 0 newlines makes NEWLINES -1, 1 newline makes NEWLINES 1, etc. Initially 0 to indicate that we are at the beginning of a new line. The "state" of the procedure is determined by NEWLINES. */ int newlines = newlines2; #ifdef FIONREAD /* If nonzero, use the FIONREAD ioctl, as an optimization. (On Ultrix, it is not supported on NFS filesystems.) */ int use_fionread = 1; #endif /* The inbuf pointers are initialized so that BPIN > EOB, and thereby input is read immediately. */ eob = inbuf; bpin = eob + 1; bpout = outbuf; for (;;) { do { /* Write if there are at least OUTSIZE bytes in OUTBUF. */ if (bpout - outbuf >= outsize) { unsigned char *wp = outbuf; do { if (full_write (output_desc, wp, outsize) < 0) error (1, errno, "write error"); wp += outsize; } while (bpout - wp >= outsize); /* Move the remaining bytes to the beginning of the buffer. */ memmove (outbuf, wp, bpout - wp); bpout = outbuf + (bpout - wp); } /* Is INBUF empty? */ if (bpin > eob) { #ifdef FIONREAD int n_to_read = 0; /* Is there any input to read immediately? If not, we are about to wait, so write all buffered output before waiting. */ if (use_fionread && ioctl (input_desc, FIONREAD, &n_to_read) < 0) { /* Ultrix returns EOPNOTSUPP on NFS; HP-UX returns ENOTTY on pipes. SunOS returns EINVAL and More/BSD returns ENODEV on special files like /dev/null. Irix-5 returns ENOSYS on pipes. */ if (errno == EOPNOTSUPP || errno == ENOTTY || errno == EINVAL || errno == ENODEV #ifdef ENOSYS || errno == ENOSYS #endif ) use_fionread = 0; else { error (0, errno, "cannot do ioctl on `%s'", infile); exit_stat = 1; newlines2 = newlines; return; } } if (n_to_read == 0) #endif { int n_write = bpout - outbuf; if (full_write (output_desc, outbuf, n_write) < 0) error (1, errno, "write error"); bpout = outbuf; } /* Read more input into INBUF. */ n_read = safe_read (input_desc, inbuf, insize); if (n_read < 0) { error (0, errno, "%s", infile); exit_stat = 1; newlines2 = newlines; return; } if (n_read == 0) { newlines2 = newlines; return; } /* Update the pointers and insert a sentinel at the buffer end. */ bpin = inbuf; eob = bpin + n_read; *eob = '\n'; } else { /* It was a real (not a sentinel) newline. */ /* Was the last line empty? (i.e. have two or more consecutive newlines been read?) */ if (++newlines > 0) { /* Are multiple adjacent empty lines to be substituted by single ditto (-s), and this was the second empty line? */ if (squeeze_empty_lines && newlines >= 2) { ch = *bpin++; continue; } /* Are line numbers to be written at empty lines (-n)? */ if (numbers && numbers_at_empty_lines) { next_line_num (); bpout = (unsigned char *) stpcpy (bpout, line_num_print); } } /* Output a currency symbol if requested (-e). */ if (mark_line_ends) *bpout++ = '$'; /* Output the newline. */ *bpout++ = '\n'; } ch = *bpin++; } while (ch == '\n'); /* Are we at the beginning of a line, and line numbers are requested? */ if (newlines >= 0 && numbers) { next_line_num (); bpout = (unsigned char *) stpcpy (bpout, line_num_print); } /* Here CH cannot contain a newline character. */ /* The loops below continue until a newline character is found, which means that the buffer is empty or that a proper newline has been found. */ /* If quoting, i.e. at least one of -v, -e, or -t specified, scan for chars that need conversion. */ if (quote) for (;;) { 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 if (ch == '\t' && output_tabs) *bpout++ = '\t'; else if (ch == '\n') { newlines = -1; break; } else *bpout++ = '^', *bpout++ = ch + 64; ch = *bpin++; } else /* Not quoting, neither of -v, -e, or -t specified. */ for (;;) { if (ch == '\t' && !output_tabs) *bpout++ = '^', *bpout++ = ch + 64; else if (ch != '\n') *bpout++ = ch; else { newlines = -1; break; } ch = *bpin++; } } } /* Compute the next line number. */ static void next_line_num () { char *endp = line_num_end; do { if ((*endp)++ < '9') return; *endp-- = '0'; } while (endp >= line_num_start); *--line_num_start = '1'; if (line_num_start < line_num_print) line_num_print--; } textutils-1.12/src/cksum.c100666 74504 13 22720 5770310523 14666 0ustar meyeringuser/* cksum -- calculate and print POSIX.2 checksums and sizes of files Copyright (C) 1992, 1995 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* Written by Q. Frank Xia, qx@math.columbia.edu. Cosmetic changes and reorganization by David MacKenzie, djm@gnu.ai.mit.edu. Usage: cksum [file...] The code segment between "#ifdef CRCTAB" and "#else" is the code which calculates the "crctab". It is included for those who want verify the correctness of the "crctab". To recreate the "crctab", do following: cc -DCRCTAB -o crctab cksum.c crctab > crctab.h As Bruce Evans pointed out to me, the crctab in the sample C code in 4.9.10 Rationale of P1003.2/D11.2 is represented in reversed order. Namely, 0x01 is represented as 0x80, 0x02 is represented as 0x40, etc. The generating polynomial is crctab[0x80]=0xedb88320 instead of crctab[1]=0x04C11DB7. But the code works only for a non-reverse order crctab. Therefore, the sample implementation is wrong. This software is compatible with neither the System V nor the BSD `sum' program. It is supposed to conform to P1003.2/D11.2, except foreign language interface (4.9.5.3 of P1003.2/D11.2) support. Any inconsistency with the standard except 4.9.5.3 is a bug. */ #include #ifdef CRCTAB #include #define BIT(x) ( (unsigned long)1 << (x) ) #define SBIT BIT(31) /* The generating polynomial is 32 26 23 22 16 12 11 10 8 7 5 4 2 1 G(X)=X + X + X + X + X + X + X + X + X + X + X + X + X + X + 1 The i bit in GEN is set if X^i is a summand of G(X) except X^32. */ #define GEN (BIT(26)|BIT(23)|BIT(22)|BIT(16)|BIT(12)|BIT(11)|BIT(10)\ |BIT(8) |BIT(7) |BIT(5) |BIT(4) |BIT(2) |BIT(1) |BIT(0)); static unsigned long r[8]; static void fill_r () { int i; r[0] = GEN; for (i = 1; i < 8; i++) r[i] = (r[i - 1] & SBIT) ? (r[i - 1] << 1) ^ r[0] : r[i - 1] << 1; } static unsigned long remainder (m) int m; { unsigned long rem = 0; int i; for (i = 0; i < 8; i++) if (BIT (i) & m) rem = rem ^ r[i]; return rem & 0xFFFFFFFF; /* Make it run on 64-bit machine. */ } void main () { int i; fill_r (); printf ("unsigned long crctab[256] = {\n 0x0"); for (i = 0; i < 51; i++) { printf (",\n 0x%08X, 0x%08X, 0x%08X, 0x%08X, 0x%08X", remainder (i * 5 + 1), remainder (i * 5 + 2), remainder (i * 5 + 3), remainder (i * 5 + 4), remainder (i * 5 + 5)); } printf ("\n};\n"); exit (0); } #else /* !CRCTAB */ #include #include #include #include "system.h" #include "version.h" #include "error.h" /* Number of bytes to read at once. */ #define BUFLEN (1 << 16) /* 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 then 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 unsigned long const crctab[256] = { 0x0, 0x04C11DB7, 0x09823B6E, 0x0D4326D9, 0x130476DC, 0x17C56B6B, 0x1A864DB2, 0x1E475005, 0x2608EDB8, 0x22C9F00F, 0x2F8AD6D6, 0x2B4BCB61, 0x350C9B64, 0x31CD86D3, 0x3C8EA00A, 0x384FBDBD, 0x4C11DB70, 0x48D0C6C7, 0x4593E01E, 0x4152FDA9, 0x5F15ADAC, 0x5BD4B01B, 0x569796C2, 0x52568B75, 0x6A1936C8, 0x6ED82B7F, 0x639B0DA6, 0x675A1011, 0x791D4014, 0x7DDC5DA3, 0x709F7B7A, 0x745E66CD, 0x9823B6E0, 0x9CE2AB57, 0x91A18D8E, 0x95609039, 0x8B27C03C, 0x8FE6DD8B, 0x82A5FB52, 0x8664E6E5, 0xBE2B5B58, 0xBAEA46EF, 0xB7A96036, 0xB3687D81, 0xAD2F2D84, 0xA9EE3033, 0xA4AD16EA, 0xA06C0B5D, 0xD4326D90, 0xD0F37027, 0xDDB056FE, 0xD9714B49, 0xC7361B4C, 0xC3F706FB, 0xCEB42022, 0xCA753D95, 0xF23A8028, 0xF6FB9D9F, 0xFBB8BB46, 0xFF79A6F1, 0xE13EF6F4, 0xE5FFEB43, 0xE8BCCD9A, 0xEC7DD02D, 0x34867077, 0x30476DC0, 0x3D044B19, 0x39C556AE, 0x278206AB, 0x23431B1C, 0x2E003DC5, 0x2AC12072, 0x128E9DCF, 0x164F8078, 0x1B0CA6A1, 0x1FCDBB16, 0x018AEB13, 0x054BF6A4, 0x0808D07D, 0x0CC9CDCA, 0x7897AB07, 0x7C56B6B0, 0x71159069, 0x75D48DDE, 0x6B93DDDB, 0x6F52C06C, 0x6211E6B5, 0x66D0FB02, 0x5E9F46BF, 0x5A5E5B08, 0x571D7DD1, 0x53DC6066, 0x4D9B3063, 0x495A2DD4, 0x44190B0D, 0x40D816BA, 0xACA5C697, 0xA864DB20, 0xA527FDF9, 0xA1E6E04E, 0xBFA1B04B, 0xBB60ADFC, 0xB6238B25, 0xB2E29692, 0x8AAD2B2F, 0x8E6C3698, 0x832F1041, 0x87EE0DF6, 0x99A95DF3, 0x9D684044, 0x902B669D, 0x94EA7B2A, 0xE0B41DE7, 0xE4750050, 0xE9362689, 0xEDF73B3E, 0xF3B06B3B, 0xF771768C, 0xFA325055, 0xFEF34DE2, 0xC6BCF05F, 0xC27DEDE8, 0xCF3ECB31, 0xCBFFD686, 0xD5B88683, 0xD1799B34, 0xDC3ABDED, 0xD8FBA05A, 0x690CE0EE, 0x6DCDFD59, 0x608EDB80, 0x644FC637, 0x7A089632, 0x7EC98B85, 0x738AAD5C, 0x774BB0EB, 0x4F040D56, 0x4BC510E1, 0x46863638, 0x42472B8F, 0x5C007B8A, 0x58C1663D, 0x558240E4, 0x51435D53, 0x251D3B9E, 0x21DC2629, 0x2C9F00F0, 0x285E1D47, 0x36194D42, 0x32D850F5, 0x3F9B762C, 0x3B5A6B9B, 0x0315D626, 0x07D4CB91, 0x0A97ED48, 0x0E56F0FF, 0x1011A0FA, 0x14D0BD4D, 0x19939B94, 0x1D528623, 0xF12F560E, 0xF5EE4BB9, 0xF8AD6D60, 0xFC6C70D7, 0xE22B20D2, 0xE6EA3D65, 0xEBA91BBC, 0xEF68060B, 0xD727BBB6, 0xD3E6A601, 0xDEA580D8, 0xDA649D6F, 0xC423CD6A, 0xC0E2D0DD, 0xCDA1F604, 0xC960EBB3, 0xBD3E8D7E, 0xB9FF90C9, 0xB4BCB610, 0xB07DABA7, 0xAE3AFBA2, 0xAAFBE615, 0xA7B8C0CC, 0xA379DD7B, 0x9B3660C6, 0x9FF77D71, 0x92B45BA8, 0x9675461F, 0x8832161A, 0x8CF30BAD, 0x81B02D74, 0x857130C3, 0x5D8A9099, 0x594B8D2E, 0x5408ABF7, 0x50C9B640, 0x4E8EE645, 0x4A4FFBF2, 0x470CDD2B, 0x43CDC09C, 0x7B827D21, 0x7F436096, 0x7200464F, 0x76C15BF8, 0x68860BFD, 0x6C47164A, 0x61043093, 0x65C52D24, 0x119B4BE9, 0x155A565E, 0x18197087, 0x1CD86D30, 0x029F3D35, 0x065E2082, 0x0B1D065B, 0x0FDC1BEC, 0x3793A651, 0x3352BBE6, 0x3E119D3F, 0x3AD08088, 0x2497D08D, 0x2056CD3A, 0x2D15EBE3, 0x29D4F654, 0xC5A92679, 0xC1683BCE, 0xCC2B1D17, 0xC8EA00A0, 0xD6AD50A5, 0xD26C4D12, 0xDF2F6BCB, 0xDBEE767C, 0xE3A1CBC1, 0xE760D676, 0xEA23F0AF, 0xEEE2ED18, 0xF0A5BD1D, 0xF464A0AA, 0xF9278673, 0xFDE69BC4, 0x89B8FD09, 0x8D79E0BE, 0x803AC667, 0x84FBDBD0, 0x9ABC8BD5, 0x9E7D9662, 0x933EB0BB, 0x97FFAD0C, 0xAFB010B1, 0xAB710D06, 0xA6322BDF, 0xA2F33668, 0xBCB4666D, 0xB8757BDA, 0xB5365D03, 0xB1F740B4 }; /* Nonzero if any of the files read were the standard input. */ static int have_read_stdin; /* Calculate and print the checksum and length in bytes of file FILE, or of the standard input if FILE is "-". If PRINT_NAME is nonzero, print FILE next to the checksum and size. Return 0 if successful, -1 if an error occurs. */ static int cksum (file, print_name) char *file; int print_name; { unsigned char buf[BUFLEN]; unsigned long crc = 0; long length = 0; long bytes_read; register FILE *fp; if (!strcmp (file, "-")) { fp = stdin; have_read_stdin = 1; } else { fp = fopen (file, "r"); if (fp == NULL) { error (0, errno, "%s", file); return -1; } } while ((bytes_read = fread (buf, 1, BUFLEN, fp)) > 0) { unsigned char *cp = buf; length += bytes_read; while (bytes_read--) crc = (crc << 8) ^ crctab[((crc >> 24) ^ *(cp++)) & 0xFF]; } if (ferror (fp)) { error (0, errno, "%s", file); if (strcmp (file, "-")) fclose (fp); return -1; } if (strcmp (file, "-") && fclose (fp) == EOF) { error (0, errno, "%s", file); return -1; } bytes_read = length; while (bytes_read > 0) { crc = (crc << 8) ^ crctab[((crc >> 24) ^ bytes_read) & 0xFF]; bytes_read >>= 8; } crc = ~crc & 0xFFFFFFFF; printf ("%10lu %8ld", crc, length); if (print_name) printf (" %s", file); putchar ('\n'); 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]... [FILE]...\n\ ", program_name); printf ("\ Print CRC checksum and byte counts of each FILE.\n\ \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 i, c; int errors = 0; program_name = argv[0]; have_read_stdin = 0; while ((c = getopt_long (argc, argv, "", long_options, (int *) 0)) != EOF) { switch (c) { case 0: break; default: usage (1); } } if (show_version) { printf ("cksum - %s\n", version_string); exit (0); } if (show_help) usage (0); if (optind >= argc) { if (cksum ("-", 0) < 0) errors = 1; } else { for (i = optind; i < argc; i++) if (cksum (argv[i], 1) < 0) errors = 1; } if (have_read_stdin && fclose (stdin) == EOF) error (1, errno, "-"); exit (errors); } #endif /* !CRCTAB */ textutils-1.12/src/comm.c100666 74504 13 14277 5770310533 14510 0ustar meyeringuser/* comm -- compare two sorted files line by line. Copyright (C) 1986, 1990, 1991, 1995 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* Written by Richard Stallman and David MacKenzie. */ #include #include #include #include #include "system.h" #include "linebuffer.h" #include "version.h" #include "error.h" #define min(x, y) ((x) < (y) ? (x) : (y)) /* The name this program was run with. */ char *program_name; /* If nonzero, print lines that are found only in file 1. */ static int only_file_1; /* If nonzero, print lines that are found only in file 2. */ static int only_file_2; /* If nonzero, print lines that are found in both files. */ static int both; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output then 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 int compare_files (); static void writeline (); static void usage (); void main (argc, argv) int argc; char *argv[]; { int c; program_name = argv[0]; only_file_1 = 1; only_file_2 = 1; both = 1; while ((c = getopt_long (argc, argv, "123", long_options, (int *) 0)) != EOF) switch (c) { case 0: break; case '1': only_file_1 = 0; break; case '2': only_file_2 = 0; break; case '3': both = 0; break; default: usage (1); } if (show_version) { printf ("comm - %s\n", version_string); exit (0); } if (show_help) usage (0); if (optind + 2 != argc) usage (1); exit (compare_files (argv + optind)); } /* Compare INFILES[0] and INFILES[1]. If either is "-", use the standard input for that file. Assume that each input file is sorted; merge them and output the result. Return 0 if successful, 1 if any errors occur. */ static int compare_files (infiles) char **infiles; { /* For each file, we have one linebuffer in lb1. */ struct linebuffer lb1[2]; /* thisline[i] points to the linebuffer holding the next available line in file i, or is NULL if there are no lines left in that file. */ struct linebuffer *thisline[2]; /* streams[i] holds the input stream for file i. */ FILE *streams[2]; int i, ret = 0; /* Initialize the storage. */ for (i = 0; i < 2; i++) { initbuffer (&lb1[i]); thisline[i] = &lb1[i]; streams[i] = strcmp (infiles[i], "-") ? fopen (infiles[i], "r") : stdin; if (!streams[i]) { error (0, errno, "%s", infiles[i]); return 1; } thisline[i] = readline (thisline[i], streams[i]); } while (thisline[0] || thisline[1]) { int order; /* Compare the next available lines of the two files. */ if (!thisline[0]) order = 1; else if (!thisline[1]) order = -1; else { /* Cannot use bcmp -- it only returns a boolean value. */ order = memcmp (thisline[0]->buffer, thisline[1]->buffer, min (thisline[0]->length, thisline[1]->length)); if (order == 0) order = thisline[0]->length - thisline[1]->length; } /* Output the line that is lesser. */ if (order == 0) writeline (thisline[1], stdout, 3); else if (order > 0) writeline (thisline[1], stdout, 2); else writeline (thisline[0], stdout, 1); /* Step the file the line came from. If the files match, step both files. */ if (order >= 0) thisline[1] = readline (thisline[1], streams[1]); if (order <= 0) thisline[0] = readline (thisline[0], streams[0]); } /* Free all storage and close all input streams. */ for (i = 0; i < 2; i++) { free (lb1[i].buffer); if (ferror (streams[i]) || fclose (streams[i]) == EOF) { error (0, errno, "%s", infiles[i]); ret = 1; } } if (ferror (stdout) || fclose (stdout) == EOF) { error (0, errno, "write error"); ret = 1; } return ret; } /* Output the line in linebuffer LINE to stream STREAM provided the switches say it should be output. CLASS is 1 for a line found only in file 1, 2 for a line only in file 2, 3 for a line in both. */ static void writeline (line, stream, class) struct linebuffer *line; FILE *stream; int class; { switch (class) { case 1: if (!only_file_1) return; break; case 2: if (!only_file_2) return; /* Skip the tab stop for case 1, if we are printing case 1. */ if (only_file_1) putc ('\t', stream); break; case 3: if (!both) return; /* Skip the tab stop for case 1, if we are printing case 1. */ if (only_file_1) putc ('\t', stream); /* Skip the tab stop for case 2, if we are printing case 2. */ if (only_file_2) putc ('\t', stream); break; } fwrite (line->buffer, sizeof (char), line->length, stream); putc ('\n', stream); } 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]... LEFT_FILE RIGHT_FILE\n\ ", program_name); printf ("\ Compare sorted files LEFT_FILE and RIGHT_FILE line by line.\n\ \n\ -1 suppress lines unique to left file\n\ -2 suppress lines unique to right file\n\ -3 suppress lines unique to both files\n\ --help display this help and exit\n\ --version output version information and exit\n\ "); } exit (status); } textutils-1.12/src/csplit.c100666 74504 13 110253 5770310540 15060 0ustar meyeringuser/* csplit - split a file into sections determined by context lines Copyright (C) 1991, 1995 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* Written by Stuart Kemp, cpsrk@groper.jcu.edu.au. Modified by David MacKenzie, djm@gnu.ai.mit.edu. */ #include #include #include #include #include #ifdef HAVE_LIMITS_H #include #endif /* HAVE_LIMITS_H */ #include "regex.h" #include "system.h" #include "version.h" #include "error.h" #ifdef STDC_HEADERS #include #else char *malloc (); char *realloc (); #endif #ifndef MAX #define MAX(a,b) (((a) > (b)) ? (a) : (b)) #endif int safe_read (); static char *xrealloc (); static char *xmalloc (); static void cleanup (); static void close_output_file (); static void create_output_file (); static void save_line_to_file (); static void usage (); #ifndef TRUE #define FALSE 0 #define TRUE 1 #endif /* Increment size of area for control records. */ #define ALLOC_SIZE 20 /* The default prefix for output file names. */ #define DEFAULT_PREFIX "xx" typedef int boolean; /* A compiled pattern arg. */ struct control { char *regexpr; /* Non-compiled regular expression. */ struct re_pattern_buffer re_compiled; /* Compiled regular expression. */ int offset; /* Offset from regexp to split at. */ int lines_required; /* Number of lines required. */ unsigned int repeat; /* Repeat count. */ int repeat_forever; /* Non-zero if `*' used as a repeat count. */ int argnum; /* ARGV index. */ boolean ignore; /* If true, produce no output (for regexp). */ }; /* Initial size of data area in buffers. */ #define START_SIZE 8191 /* Increment size for data area. */ #define INCR_SIZE 2048 /* Number of lines kept in each node in line list. */ #define CTRL_SIZE 80 #ifdef DEBUG /* Some small values to test the algorithms. */ #define START_SIZE 200 #define INCR_SIZE 10 #define CTRL_SIZE 1 #endif /* A string with a length count. */ struct cstring { int len; char *str; }; /* Pointers to the beginnings of lines in the buffer area. These structures are linked together if needed. */ struct line { unsigned used; /* Number of offsets used in this struct. */ unsigned insert_index; /* Next offset to use when inserting line. */ unsigned retrieve_index; /* Next index to use when retrieving line. */ struct cstring starts[CTRL_SIZE]; /* Lines in the data area. */ struct line *next; /* Next in linked list. */ }; /* The structure to hold the input lines. Contains a pointer to the data area and a list containing pointers to the individual lines. */ struct buffer_record { unsigned bytes_alloc; /* Size of the buffer area. */ unsigned bytes_used; /* Bytes used in the buffer area. */ unsigned start_line; /* First line number in this buffer. */ unsigned first_available; /* First line that can be retrieved. */ unsigned num_lines; /* Number of complete lines in this buffer. */ char *buffer; /* Data area. */ struct line *line_start; /* Head of list of pointers to lines. */ struct line *curr_line; /* The line start record currently in use. */ struct buffer_record *next; }; /* The name this program was run with. */ char *program_name; /* Convert the number of 8-bit bytes of a binary representation to the number of characters required to represent the same quantity as an unsigned octal. For example, a 32-bit (4-byte) quantity may require a field width as wide as 11 characters. */ static const unsigned int bytes_to_octal_digits[] = {0, 3, 6, 8, 11, 14, 16, 19, 22, 25, 27, 30, 32, 35, 38, 41, 43}; /* Input file descriptor. */ static int input_desc = 0; /* List of available buffers. */ static struct buffer_record *free_list = NULL; /* Start of buffer list. */ static struct buffer_record *head = NULL; /* Partially read line. */ static char *hold_area = NULL; /* Number of chars in `hold_area'. */ static unsigned hold_count = 0; /* Number of the last line in the buffers. */ static unsigned last_line_number = 0; /* Number of the line currently being examined. */ static unsigned current_line = 0; /* If TRUE, we have read EOF. */ static boolean have_read_eof = FALSE; /* Name of output files. */ static char *filename_space = NULL; /* Prefix part of output file names. */ static char *prefix = NULL; /* Suffix part of output file names. */ static char *suffix = NULL; /* Number of digits to use in output file names. */ static int digits = 2; /* Number of files created so far. */ static unsigned int files_created = 0; /* Number of bytes written to current file. */ static unsigned int bytes_written; /* Output file pointer. */ static FILE *output_stream = NULL; /* Output file name. */ static char *output_filename = NULL; /* Perhaps it would be cleaner to pass arg values instead of indexes. */ static char **global_argv; /* If TRUE, do not print the count of bytes in each output file. */ static boolean suppress_count; /* If TRUE, remove output files on error. */ static boolean remove_files; /* If TRUE, remove all output files which have a zero length. */ static boolean elide_empty_files; /* The compiled pattern arguments, which determine how to split the input file. */ static struct control *controls; /* Number of elements in `controls'. */ static unsigned int control_used; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output then exit. */ static int show_version; static struct option const longopts[] = { {"digits", required_argument, NULL, 'n'}, {"quiet", no_argument, NULL, 'q'}, {"silent", no_argument, NULL, 's'}, {"keep-files", no_argument, NULL, 'k'}, {"elide-empty-files", no_argument, NULL, 'z'}, {"prefix", required_argument, NULL, 'f'}, {"suffix-format", required_argument, NULL, 'b'}, {"help", no_argument, &show_help, 1}, {"version", no_argument, &show_version, 1}, {NULL, 0, NULL, 0} }; /* Allocate N bytes of memory dynamically, with error checking. */ static char * xmalloc (n) unsigned int n; { char *p; p = malloc (n); if (p == NULL) { error (0, 0, "virtual memory exhausted"); cleanup (); } 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. */ static char * xrealloc (p, n) char *p; unsigned int n; { if (p == NULL) return xmalloc (n); if (n == 0) { free (p); return 0; } p = realloc (p, n); if (p == NULL) { error (0, 0, "virtual memory exhausted"); cleanup (); } return p; } /* Keep track of NUM chars of a partial line in buffer START. These chars will be retrieved later when another large buffer is read. It is not necessary to create a new buffer for these chars; instead, we keep a pointer to the existing buffer. This buffer *is* on the free list, and when the next buffer is obtained from this list (even if it is this one), these chars will be placed at the start of the new buffer. */ static void save_to_hold_area (start, num) char *start; unsigned int num; { hold_area = start; hold_count = num; } /* Read up to MAX chars from the input stream into DEST. Return the number of chars read. */ static int read_input (dest, max) char *dest; unsigned int max; { int bytes_read; if (max == 0) return 0; bytes_read = safe_read (input_desc, dest, max); if (bytes_read == 0) have_read_eof = TRUE; if (bytes_read < 0) { error (0, errno, "read error"); cleanup (); } return bytes_read; } /* Initialize existing line record P. */ static void clear_line_control (p) struct line *p; { p->used = 0; p->insert_index = 0; p->retrieve_index = 0; } /* Initialize all line records in B. */ static void clear_all_line_control (b) struct buffer_record *b; { struct line *l; for (l = b->line_start; l; l = l->next) clear_line_control (l); } /* Return a new, initialized line record. */ static struct line * new_line_control () { struct line *p; p = (struct line *) xmalloc (sizeof (struct line)); p->next = NULL; clear_line_control (p); return p; } /* Record LINE_START, which is the address of the start of a line of length LINE_LEN in the large buffer, in the lines buffer of B. */ static void keep_new_line (b, line_start, line_len) struct buffer_record *b; char *line_start; int line_len; { struct line *l; /* If there is no existing area to keep line info, get some. */ if (b->line_start == NULL) b->line_start = b->curr_line = new_line_control (); /* If existing area for lines is full, get more. */ if (b->curr_line->used == CTRL_SIZE) { b->curr_line->next = new_line_control (); b->curr_line = b->curr_line->next; } l = b->curr_line; /* Record the start of the line, and update counters. */ l->starts[l->insert_index].str = line_start; l->starts[l->insert_index].len = line_len; l->used++; l->insert_index++; } /* Scan the buffer in B for newline characters and record the line start locations and lengths in B. Return the number of lines found in this buffer. There may be an incomplete line at the end of the buffer; a pointer is kept to this area, which will be used when the next buffer is filled. */ static unsigned int record_line_starts (b) struct buffer_record *b; { char *line_start; /* Start of current line. */ char *line_end; /* End of each line found. */ unsigned int bytes_left; /* Length of incomplete last line. */ unsigned int lines; /* Number of lines found. */ unsigned int line_length; /* Length of each line found. */ if (b->bytes_used == 0) return 0; lines = 0; line_start = b->buffer; bytes_left = b->bytes_used; for (;;) { line_end = memchr (line_start, '\n', bytes_left); if (line_end == NULL) break; line_length = line_end - line_start + 1; keep_new_line (b, line_start, line_length); bytes_left -= line_length; line_start = line_end + 1; lines++; } /* Check for an incomplete last line. */ if (bytes_left) { if (have_read_eof) { keep_new_line (b, line_start, bytes_left); lines++; } else save_to_hold_area (line_start, bytes_left); } b->num_lines = lines; b->first_available = b->start_line = last_line_number + 1; last_line_number += lines; return lines; } /* Return a new buffer with room to store SIZE bytes, plus an extra byte for safety. */ static struct buffer_record * create_new_buffer (size) unsigned int size; { struct buffer_record *new_buffer; new_buffer = (struct buffer_record *) xmalloc (sizeof (struct buffer_record)); new_buffer->buffer = (char *) xmalloc (size + 1); new_buffer->bytes_alloc = size; new_buffer->line_start = new_buffer->curr_line = NULL; return new_buffer; } /* Return a new buffer of at least MINSIZE bytes. If a buffer of at least that size is currently free, use it, otherwise create a new one. */ static struct buffer_record * get_new_buffer (min_size) unsigned int min_size; { struct buffer_record *p, *q; struct buffer_record *new_buffer; /* Buffer to return. */ unsigned int alloc_size; /* Actual size that will be requested. */ alloc_size = START_SIZE; while (min_size > alloc_size) alloc_size += INCR_SIZE; if (free_list == NULL) new_buffer = create_new_buffer (alloc_size); else { /* Use first-fit to find a buffer. */ p = new_buffer = NULL; q = free_list; do { if (q->bytes_alloc >= min_size) { if (p == NULL) free_list = q->next; else p->next = q->next; break; } p = q; q = q->next; } while (q); new_buffer = (q ? q : create_new_buffer (alloc_size)); new_buffer->curr_line = new_buffer->line_start; clear_all_line_control (new_buffer); } new_buffer->num_lines = 0; new_buffer->bytes_used = 0; new_buffer->start_line = new_buffer->first_available = last_line_number + 1; new_buffer->next = NULL; return new_buffer; } /* Add buffer BUF to the list of free buffers. */ static void free_buffer (buf) struct buffer_record *buf; { buf->next = free_list; free_list = buf; } /* Append buffer BUF to the linked list of buffers that contain some data yet to be processed. */ static void save_buffer (buf) struct buffer_record *buf; { struct buffer_record *p; buf->next = NULL; buf->curr_line = buf->line_start; if (head == NULL) head = buf; else { for (p = head; p->next; p = p->next) /* Do nothing. */ ; p->next = buf; } } /* Fill a buffer of input. Set the initial size of the buffer to a default. Fill the buffer (from the hold area and input stream) and find the individual lines. If no lines are found (the buffer is too small to hold the next line), release the current buffer (whose contents would have been put in the hold area) and repeat the process with another large buffer until at least one entire line has been read. Return TRUE if a new buffer was obtained, otherwise false (in which case end-of-file must have been encountered). */ static boolean load_buffer () { struct buffer_record *b; unsigned int bytes_wanted = START_SIZE; /* Minimum buffer size. */ unsigned int bytes_avail; /* Size of new buffer created. */ unsigned int lines_found; /* Number of lines in this new buffer. */ char *p; /* Place to load into buffer. */ if (have_read_eof) return FALSE; /* We must make the buffer at least as large as the amount of data in the partial line left over from the last call. */ if (bytes_wanted < hold_count) bytes_wanted = hold_count; do { b = get_new_buffer (bytes_wanted); bytes_avail = b->bytes_alloc; /* Size of buffer returned. */ p = b->buffer; /* First check the `holding' area for a partial line. */ if (hold_count) { if (p != hold_area) memcpy (p, hold_area, hold_count); p += hold_count; b->bytes_used += hold_count; bytes_avail -= hold_count; hold_count = 0; } b->bytes_used += (unsigned int) read_input (p, bytes_avail); lines_found = record_line_starts (b); bytes_wanted = b->bytes_alloc * 2; if (!lines_found) free_buffer (b); } while (!lines_found && !have_read_eof); if (lines_found) save_buffer (b); return lines_found != 0; } /* Return the line number of the first line that has not yet been retrieved. */ static unsigned int get_first_line_in_buffer () { if (head == NULL && !load_buffer ()) error (1, errno, "input disappeared"); return head->first_available; } /* Return a pointer to the logical first line in the buffer and make the next line the logical first line. Return NULL if there is no more input. */ static struct cstring * remove_line () { struct cstring *line; /* Return value. */ struct line *l; /* For convenience. */ if (head == NULL && !load_buffer ()) return NULL; if (current_line < head->first_available) current_line = head->first_available; ++(head->first_available); l = head->curr_line; line = &l->starts[l->retrieve_index]; /* Advance index to next line. */ if (++l->retrieve_index == l->used) { /* Go on to the next line record. */ head->curr_line = l->next; if (head->curr_line == NULL || head->curr_line->used == 0) { /* Go on to the next data block. */ struct buffer_record *b = head; head = head->next; free_buffer (b); } } return line; } /* Search the buffers for line LINENUM, reading more input if necessary. Return a pointer to the line, or NULL if it is not found in the file. */ static struct cstring * find_line (linenum) unsigned int linenum; { struct buffer_record *b; if (head == NULL && !load_buffer ()) return NULL; if (linenum < head->start_line) return NULL; for (b = head;;) { if (linenum < b->start_line + b->num_lines) { /* The line is in this buffer. */ struct line *l; unsigned int offset; /* How far into the buffer the line is. */ l = b->line_start; offset = linenum - b->start_line; /* Find the control record. */ while (offset >= CTRL_SIZE) { l = l->next; offset -= CTRL_SIZE; } return &l->starts[offset]; } if (b->next == NULL && !load_buffer ()) return NULL; b = b->next; /* Try the next data block. */ } } /* Return TRUE if at least one more line is available for input. */ static boolean no_more_lines () { return (find_line (current_line + 1) == NULL) ? TRUE : FALSE; } /* Set the name of the input file to NAME and open it. */ static void set_input_file (name) char *name; { if (!strcmp (name, "-")) input_desc = 0; else { input_desc = open (name, O_RDONLY); if (input_desc < 0) error (1, errno, "%s", name); } } /* Write all lines from the beginning of the buffer up to, but not including, line LAST_LINE, to the current output file. If IGNORE is TRUE, do not output lines selected here. ARGNUM is the index in ARGV of the current pattern. */ static void write_to_file (last_line, ignore, argnum) unsigned int last_line; boolean ignore; int argnum; { struct cstring *line; unsigned int first_line; /* First available input line. */ unsigned int lines; /* Number of lines to output. */ unsigned int i; first_line = get_first_line_in_buffer (); if (first_line > last_line) { error (0, 0, "%s: line number out of range", global_argv[argnum]); cleanup (); } lines = last_line - first_line; for (i = 0; i < lines; i++) { line = remove_line (); if (line == NULL) { error (0, 0, "%s: line number out of range", global_argv[argnum]); cleanup (); } if (!ignore) save_line_to_file (line); } } /* Output any lines left after all regexps have been processed. */ static void dump_rest_of_file () { struct cstring *line; while ((line = remove_line ()) != NULL) save_line_to_file (line); } /* Handle an attempt to read beyond EOF under the control of record P, on iteration REPETITION if nonzero. */ static void handle_line_error (p, repetition) struct control *p; int repetition; { fprintf (stderr, "%s: `%d': line number out of range", program_name, p->lines_required); if (repetition) fprintf (stderr, " on repetition %d\n", repetition); else fprintf (stderr, "\n"); cleanup (); } /* Determine the line number that marks the end of this file, then get those lines and save them to the output file. P is the control record. REPETITION is the repetition number. */ static void process_line_count (p, repetition) struct control *p; int repetition; { unsigned int linenum; unsigned int last_line_to_save = p->lines_required * (repetition + 1); struct cstring *line; create_output_file (); linenum = get_first_line_in_buffer (); /* Check for requesting a line that has already been written out. If this ever happens, it's due to a bug in csplit. */ if (linenum >= last_line_to_save) abort (); while (linenum++ < last_line_to_save) { line = remove_line (); if (line == NULL) handle_line_error (p, repetition); save_line_to_file (line); } close_output_file (); /* Ensure that the line number specified is not 1 greater than the number of lines in the file. */ if (no_more_lines ()) handle_line_error (p, repetition); } static void regexp_error (p, repetition, ignore) struct control *p; int repetition; boolean ignore; { fprintf (stderr, "%s: `%s': match not found", program_name, global_argv[p->argnum]); if (repetition) fprintf (stderr, " on repetition %d\n", repetition); else fprintf (stderr, "\n"); if (!ignore) { dump_rest_of_file (); close_output_file (); } cleanup (); } /* Read the input until a line matches the regexp in P, outputting it unless P->IGNORE is TRUE. REPETITION is this repeat-count; 0 means the first time. */ static void process_regexp (p, repetition) struct control *p; int repetition; { struct cstring *line; /* From input file. */ unsigned int line_len; /* To make "$" in regexps work. */ unsigned int break_line; /* First line number of next file. */ boolean ignore = p->ignore; /* If TRUE, skip this section. */ int ret; if (!ignore) create_output_file (); /* If there is no offset for the regular expression, or it is positive, then it is not necessary to buffer the lines. */ if (p->offset >= 0) { for (;;) { line = find_line (++current_line); if (line == NULL) { if (p->repeat_forever) { if (!ignore) { dump_rest_of_file (); close_output_file (); } exit (0); } else regexp_error (p, repetition, ignore); } line_len = line->len; if (line->str[line_len - 1] == '\n') line_len--; ret = re_search (&p->re_compiled, line->str, line_len, 0, line_len, (struct re_registers *) 0); if (ret == -2) { error (0, 0, "error in regular expression search"); cleanup (); } if (ret == -1) { line = remove_line (); if (!ignore) save_line_to_file (line); } else break; } } else { /* Buffer the lines. */ for (;;) { line = find_line (++current_line); if (line == NULL) { if (p->repeat_forever) { if (!ignore) { dump_rest_of_file (); close_output_file (); } exit (0); } else regexp_error (p, repetition, ignore); } line_len = line->len; if (line->str[line_len - 1] == '\n') line_len--; ret = re_search (&p->re_compiled, line->str, line_len, 0, line_len, (struct re_registers *) 0); if (ret == -2) { error (0, 0, "error in regular expression search"); cleanup (); } if (ret >= 0) break; } } /* Account for any offset from this regexp. */ break_line = current_line + p->offset; write_to_file (break_line, ignore, p->argnum); if (!ignore) close_output_file (); current_line = break_line; } /* Split the input file according to the control records we have built. */ static void split_file () { unsigned int i, j; for (i = 0; i < control_used; i++) { if (controls[i].regexpr) { for (j = 0; (controls[i].repeat_forever || j <= controls[i].repeat); j++) process_regexp (&controls[i], j); } else { for (j = 0; (controls[i].repeat_forever || j <= controls[i].repeat); j++) process_line_count (&controls[i], j); } } create_output_file (); dump_rest_of_file (); close_output_file (); } /* Return the name of output file number NUM. */ static char * make_filename (num) unsigned int num; { strcpy (filename_space, prefix); if (suffix) sprintf (filename_space+strlen(prefix), suffix, num); else sprintf (filename_space+strlen(prefix), "%0*d", digits, num); return filename_space; } /* Create the next output file. */ static void create_output_file () { output_filename = make_filename (files_created); output_stream = fopen (output_filename, "w"); if (output_stream == NULL) { error (0, errno, "%s", output_filename); cleanup (); } files_created++; bytes_written = 0; } /* Delete all the files we have created. */ static void delete_all_files () { unsigned int i; char *name; for (i = 0; i < files_created; i++) { name = make_filename (i); if (unlink (name)) error (0, errno, "%s", name); } } /* Close the current output file and print the count of characters in this file. */ static void close_output_file () { if (output_stream) { if (fclose (output_stream) == EOF) { error (0, errno, "write error for `%s'", output_filename); cleanup (); } if (bytes_written == 0 && elide_empty_files) { if (unlink (output_filename)) error (0, errno, "%s", output_filename); files_created--; } else if (!suppress_count) fprintf (stdout, "%d\n", bytes_written); output_stream = NULL; } } /* Optionally remove files created so far; then exit. Called when an error detected. */ static void cleanup () { if (output_stream) close_output_file (); if (remove_files) delete_all_files (); exit (1); } /* Save line LINE to the output file and increment the character count for the current file. */ static void save_line_to_file (line) struct cstring *line; { fwrite (line->str, sizeof (char), line->len, output_stream); bytes_written += line->len; } /* Return a new, initialized control record. */ static struct control * new_control_record () { static unsigned control_allocated = 0; /* Total space allocated. */ struct control *p; if (control_allocated == 0) { control_allocated = ALLOC_SIZE; controls = (struct control *) xmalloc (sizeof (struct control) * control_allocated); } else if (control_used == control_allocated) { control_allocated += ALLOC_SIZE; controls = (struct control *) xrealloc (controls, sizeof (struct control) * control_allocated); } p = &controls[control_used++]; p->regexpr = NULL; p->repeat = 0; p->repeat_forever = 0; p->lines_required = 0; p->offset = 0; return p; } /* Convert string NUM to an integer and put the value in *RESULT. Return a TRUE if the string consists entirely of digits, FALSE if not. */ /* FIXME: use xstrtoul in place of this function. */ static boolean string_to_number (result, num) int *result; char *num; { char ch; int val = 0; if (*num == '\0') return FALSE; while ((ch = *num++)) { if (!ISDIGIT (ch)) return FALSE; val = val * 10 + ch - '0'; } *result = val; return TRUE; } /* Check if there is a numeric offset after a regular expression. STR is the entire command line argument. P is the control record for this regular expression. NUM is the numeric part of STR. */ static void check_for_offset (p, str, num) struct control *p; char *str; char *num; { if (*num != '-' && *num != '+') error (1, 0, "%s: `+' or `-' expected after delimeter", str); if (!string_to_number (&p->offset, num + 1)) error (1, 0, "%s: integer expected after `%c'", str, *num); if (*num == '-') p->offset = -p->offset; } /* Given that the first character of command line arg STR is '{', make sure that the rest of the string is a valid repeat count and store its value in P. ARGNUM is the ARGV index of STR. */ static void parse_repeat_count (argnum, p, str) int argnum; struct control *p; char *str; { char *end; end = str + strlen (str) - 1; if (*end != '}') error (1, 0, "%s: `}' is required in repeat count", str); *end = '\0'; if (str+1 == end-1 && *(str+1) == '*') p->repeat_forever = 1; else if (!string_to_number (&p->repeat, str + 1)) error (1, 0, "%s}: integer required between `{' and `}'", global_argv[argnum]); *end = '}'; } /* Extract the regular expression from STR and check for a numeric offset. STR should start with the regexp delimiter character. Return a new control record for the regular expression. ARGNUM is the ARGV index of STR. Unless IGNORE is TRUE, mark these lines for output. */ static struct control * extract_regexp (argnum, ignore, str) int argnum; boolean ignore; char *str; { int len; /* Number of chars in this regexp. */ char delim = *str; char *closing_delim; struct control *p; const char *err; closing_delim = strrchr (str + 1, delim); if (closing_delim == NULL) error (1, 0, "%s: closing delimeter `%c' missing", str, delim); len = closing_delim - str - 1; p = new_control_record (); p->argnum = argnum; p->ignore = ignore; p->regexpr = (char *) xmalloc ((unsigned) (len + 1)); strncpy (p->regexpr, str + 1, len); p->re_compiled.allocated = len * 2; p->re_compiled.buffer = (unsigned char *) xmalloc (p->re_compiled.allocated); p->re_compiled.fastmap = xmalloc (256); p->re_compiled.translate = 0; err = re_compile_pattern (p->regexpr, len, &p->re_compiled); if (err) { error (0, 0, "%s: invalid regular expression: %s", str, err); cleanup (); } if (closing_delim[1]) check_for_offset (p, str, closing_delim + 1); return p; } /* Extract the break patterns from args START through ARGC - 1 of ARGV. After each pattern, check if the next argument is a repeat count. */ static void parse_patterns (argc, start, argv) int argc; int start; char **argv; { int i; /* Index into ARGV. */ struct control *p; /* New control record created. */ for (i = start; i < argc; i++) { if (*argv[i] == '/' || *argv[i] == '%') { p = extract_regexp (i, *argv[i] == '%', argv[i]); } else { p = new_control_record (); p->argnum = i; if (!string_to_number (&p->lines_required, argv[i])) error (1, 0, "%s: invalid pattern", argv[i]); } if (i + 1 < argc && *argv[i + 1] == '{') { /* We have a repeat count. */ i++; parse_repeat_count (i, p, argv[i]); } } } static unsigned get_format_flags (format_ptr) char **format_ptr; { unsigned count = 0; for (; **format_ptr; (*format_ptr)++) { switch (**format_ptr) { case '-': break; case '+': case ' ': count++; break; case '#': count += 2; /* Allow for 0x prefix preceeding an `x' conversion. */ break; default: return count; } } return count; } static unsigned get_format_width (format_ptr) char **format_ptr; { unsigned count = 0; char *start; int ch_save; start = *format_ptr; for (; **format_ptr; (*format_ptr)++) if (!ISDIGIT (**format_ptr)) break; ch_save = **format_ptr; **format_ptr = '\0'; /* In the case where no minimum field width is explicitly specified, allow for enough octal digits to represent the value of LONG_MAX. */ count = ((*format_ptr == start) ? bytes_to_octal_digits[sizeof (long)] : atoi (start)); **format_ptr = ch_save; return count; } static unsigned get_format_prec (format_ptr) char **format_ptr; { unsigned count = 0; char *start; int ch_save; int is_negative; if (**format_ptr != '.') return 0; (*format_ptr)++; if (**format_ptr == '-' || **format_ptr == '+') { is_negative = (**format_ptr == '-'); (*format_ptr)++; } else { is_negative = 0; } start = *format_ptr; for (; **format_ptr; (*format_ptr)++) if (!ISDIGIT (**format_ptr)) break; /* ANSI 4.9.6.1 says that if the precision is negative, it's as good as not there. */ if (is_negative) start = *format_ptr; ch_save = **format_ptr; **format_ptr = '\0'; count = (*format_ptr == start) ? 11 : atoi (start); **format_ptr = ch_save; return count; } static void get_format_conv_type (format_ptr) char **format_ptr; { int ch = *((*format_ptr)++); switch (ch) { case 'd': case 'i': case 'o': case 'u': case 'x': case 'X': break; case 0: error (1, 0, "missing conversion specifier in suffix"); break; default: if (ISPRINT (ch)) error (1, 0, "invalid conversion specifier in suffix: %c", ch); else error (1, 0, "invalid conversion specifier in suffix: \\%.3o", ch); } } static unsigned max_out (format) char *format; { unsigned out_count = 0; unsigned percents = 0; for (; *format; ) { int ch = *format++; if (ch != '%') out_count++; else { percents++; out_count += get_format_flags (&format); { int width = get_format_width (&format); int prec = get_format_prec (&format); out_count += MAX (width, prec); } get_format_conv_type (&format); } } if (percents == 0) error (1, 0, "missing %% conversion specification in suffix"); else if (percents > 1) error (1, 0, "too many %% conversion specifications in suffix"); return out_count; } static void interrupt_handler () { error (0, 0, "interrupted"); cleanup (); } void main (argc, argv) int argc; char **argv; { int optc; #ifdef _POSIX_VERSION struct sigaction oldact, newact; #endif /* _POSIX_VERSION */ program_name = argv[0]; global_argv = argv; controls = NULL; control_used = 0; suppress_count = FALSE; remove_files = TRUE; prefix = DEFAULT_PREFIX; #ifdef _POSIX_VERSION newact.sa_handler = interrupt_handler; sigemptyset (&newact.sa_mask); newact.sa_flags = 0; sigaction (SIGHUP, NULL, &oldact); if (oldact.sa_handler != SIG_IGN) sigaction (SIGHUP, &newact, NULL); sigaction (SIGINT, NULL, &oldact); if (oldact.sa_handler != SIG_IGN) sigaction (SIGINT, &newact, NULL); sigaction (SIGQUIT, NULL, &oldact); if (oldact.sa_handler != SIG_IGN) sigaction (SIGQUIT, &newact, NULL); sigaction (SIGTERM, NULL, &oldact); if (oldact.sa_handler != SIG_IGN) sigaction (SIGTERM, &newact, NULL); #else /* !_POSIX_VERSION */ if (signal (SIGHUP, SIG_IGN) != SIG_IGN) signal (SIGHUP, interrupt_handler); if (signal (SIGINT, SIG_IGN) != SIG_IGN) signal (SIGINT, interrupt_handler); if (signal (SIGQUIT, SIG_IGN) != SIG_IGN) signal (SIGQUIT, interrupt_handler); if (signal (SIGTERM, SIG_IGN) != SIG_IGN) signal (SIGTERM, interrupt_handler); #endif while ((optc = getopt_long (argc, argv, "f:b:kn:sqz", longopts, (int *) 0)) != EOF) switch (optc) { case 0: break; case 'f': prefix = optarg; break; case 'b': suffix = optarg; break; case 'k': remove_files = FALSE; break; case 'n': if (!string_to_number (&digits, optarg)) error (1, 0, "%s: invalid number", optarg); break; case 's': case 'q': suppress_count = TRUE; break; case 'z': elide_empty_files = TRUE; break; default: usage (1); } if (show_version) { printf ("csplit - %s\n", version_string); exit (0); } if (show_help) usage (0); if (optind >= argc - 1) usage (1); if (suffix) filename_space = (char *) xmalloc (strlen (prefix) + max_out (suffix) + 2); else filename_space = (char *) xmalloc (strlen (prefix) + digits + 2); set_input_file (argv[optind++]); parse_patterns (argc, optind, argv); split_file (); if (close (input_desc) < 0) { error (0, errno, "read error"); cleanup (); } exit (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 PATTERN...\n\ ", program_name); printf ("\ Output pieces of FILE separated by PATTERN(s) to files `xx01', `xx02', ...,\n\ and output byte counts of each piece to standard output.\n\ \n\ -b, --suffix-format=FORMAT use sprintf FORMAT instead of %%d\n\ -f, --prefix=PREFIX use PREFIX instead of `xx'\n\ -k, --keep-files do not remove output files on errors\n\ -n, --digits=DIGITS use specified number of digits instead of 2\n\ -s, --quiet, --silent do not print counts of output file sizes\n\ -z, --elide-empty-files remove empty output files\n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ Read standard input if FILE is -. Each PATTERN may be:\n\ \n\ INTEGER copy up to but not including specified line number\n\ /REGEXP/[OFFSET] copy up to but not including a matching line\n\ %%REGEXP%%[OFFSET] skip to, but not including a matching line\n\ {INTEGER} repeat the previous pattern specified number of times\n\ {*} repeat the previous pattern as many times as possible\n\ \n\ A line OFFSET is a required `+' or `-' followed by a positive integer.\n\ "); } exit (status); } textutils-1.12/src/cut.c100644 74504 13 47720 5757356214 14356 0ustar meyeringuser/* cut - remove parts of lines of files Copyright (C) 1984 by David M. Ihnat This program is a total rewrite of the Bell Laboratories Unix(Tm) command of the same name, as of System V. It contains no proprietary code, and therefore may be used without violation of any proprietary agreements whatsoever. However, you will notice that the program is copyrighted by me. This is to assure the program does *not* fall into the public domain. Thus, I may specify just what I am now: This program may be freely copied and distributed, provided this notice remains; it may not be sold for profit without express written consent of the author. Please note that I recreated the behavior of the Unix(Tm) 'cut' command as faithfully as possible; however, I haven't run a full set of regression tests. Thus, the user of this program accepts full responsibility for any effects or loss; in particular, the author is not responsible for any losses, explicit or incidental, that may be incurred through use of this program. I ask that any bugs (and, if possible, fixes) be reported to me when possible. -David Ihnat (312) 784-4544 ignatz@homebru.chi.il.us POSIX changes, bug fixes, long-named options, and cleanup by David MacKenzie . Rewrite cut_fields and cut_bytes -- Jim Meyering (meyering@comco.com). Options: --bytes=byte-list -b byte-list Print only the bytes in positions listed in BYTE-LIST. Tabs and backspaces are treated like any other character; they take up 1 byte. --characters=character-list -c character-list Print only characters in positions listed in CHARACTER-LIST. The same as -b for now, but internationalization will change that. Tabs and backspaces are treated like any other character; they take up 1 character. --fields=field-list -f field-list Print only the fields listed in FIELD-LIST. Fields are separated by a TAB by default. --delimiter=delim -d delim For -f, fields are separated by the first character in DELIM instead of TAB. -n Do not split multibyte chars (no-op for now). --only-delimited -s For -f, do not print lines that do not contain the field separator character. The BYTE-LIST, CHARACTER-LIST, and FIELD-LIST are one or more numbers or ranges separated by commas. The first byte, character, and field are numbered 1. A FILE of `-' means standard input. */ #include /* Get isblank from GNU libc. */ #define _GNU_SOURCE #include #define NDEBUG #include #include #include #include "system.h" #include "version.h" #include "error.h" #define FATAL_ERROR(s) \ do \ { \ error (0, 0, (s)); \ usage (2); \ } \ while (0) /* Append LOW, HIGH to the list RP of range pairs, allocating additional space if necessary. Update local variable N_RP. When allocating, update global variable N_RP_ALLOCATED. */ #define ADD_RANGE_PAIR(rp, low, high) \ do \ { \ if (n_rp >= n_rp_allocated) \ { \ n_rp_allocated *= 2; \ (rp) = (struct range_pair *) xrealloc ((rp), \ n_rp_allocated * sizeof (*(rp))); \ } \ rp[n_rp].lo = (low); \ rp[n_rp].hi = (high); \ ++n_rp; \ } \ while (0) struct range_pair { int lo; int hi; }; char *xmalloc (); char *xrealloc (); /* This buffer is used to support the semantics of the -s option (or lack of same) when the specified field list includes (does not include) the first field. In both of those cases, the entire first field must be read into this buffer to determine whether it is followed by a delimiter or a newline before any of it may be output. Otherwise, cut_fields can do the job without using this buffer. */ static char *field_1_buffer; /* The number of bytes allocated for FIELD_1_BUFFER. */ static int field_1_bufsize; /* The largest field or byte index used as an endpoint of a closed or degenerate range specification; this doesn't include the starting index of right-open-ended ranges. For example, with either range spec `2-5,9-', `2-3,5,9-' this variable would be set to 5. */ static int max_range_endpoint; /* If nonzero, this is the index of the first field in a range that goes to end of line. */ static int eol_range_start; /* In byte mode, which bytes to output. In field mode, which DELIM-separated fields to output. Both bytes and fields are numbered starting with 1, so the zeroth element of this array is unused. A field or byte K has been selected if (K <= MAX_RANGE_ENDPOINT and PRINTABLE_FIELD[K]) || (EOL_RANGE_START > 0 && K >= EOL_RANGE_START). */ static int *printable_field; enum operating_mode { undefined_mode, /* Output characters that are in the given bytes. */ byte_mode, /* Output the given delimeter-separated fields. */ field_mode }; /* The name this program was run with. */ char *program_name; static enum operating_mode operating_mode; /* If non-zero do not output lines containing no delimeter characters. Otherwise, all such lines are printed. This option is valid only with field mode. */ static int suppress_non_delimited; /* The delimeter character for field mode. */ static int delim; /* Nonzero if we have ever read standard input. */ static int have_read_stdin; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output then exit. */ static int show_version; static struct option const longopts[] = { {"bytes", required_argument, 0, 'b'}, {"characters", required_argument, 0, 'c'}, {"fields", required_argument, 0, 'f'}, {"delimiter", required_argument, 0, 'd'}, {"only-delimited", no_argument, 0, 's'}, {"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]... [FILE]...\n\ ", program_name); printf ("\ Print selected parts of lines from each FILE to standard output.\n\ \n\ -b, --bytes=LIST output only these bytes\n\ -c, --characters=LIST output only these characters\n\ -d, --delimiter=DELIM use DELIM instead of TAB for field delimiter\n\ -f, --fields=LIST output only these fields\n\ -n (ignored)\n\ -s, --only-delimited do not print lines not containing delimiters\n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ Use one, and only one of -b, -c or -f. Each LIST is made up of one\n\ range, or many ranges separated by commas. Each range is one of:\n\ \n\ N N'th byte, character or field, counted from 1\n\ N- from N'th byte, character or field, to end of line\n\ N-M from N'th to M'th (included) byte, character or field\n\ -M from first to M'th (included) byte, character or field\n\ \n\ With no FILE, or when FILE is -, read standard input.\n\ "); } exit (status); } /* The following function was copied from getline.c, but with these changes: - Read up to and including a newline or TERMINATOR, whichever comes first. The original does not treat newline specially. - Remove unused argument, OFFSET. - Use xmalloc and xrealloc instead of malloc and realloc. - Declare this function static. */ /* Always add at least this many bytes when extending the buffer. */ #define MIN_CHUNK 64 /* Read up to (and including) a newline or TERMINATOR from STREAM into *LINEPTR (and null-terminate it). *LINEPTR is a pointer returned from xmalloc (or NULL), pointing to *N characters of space. It is xrealloc'd as necessary. Return the number of characters read (not including the null terminator), or -1 on error or EOF. */ static int getstr (lineptr, n, stream, terminator) char **lineptr; int *n; FILE *stream; char terminator; { int nchars_avail; /* Allocated but unused chars in *LINEPTR. */ char *read_pos; /* Where we're reading into *LINEPTR. */ if (!lineptr || !n || !stream) return -1; if (!*lineptr) { *n = MIN_CHUNK; *lineptr = xmalloc (*n); if (!*lineptr) return -1; } nchars_avail = *n; read_pos = *lineptr; for (;;) { register int c = getc (stream); /* We always want at least one char left in the buffer, since we always (unless we get an error while reading the first char) NUL-terminate the line buffer. */ assert (*n - nchars_avail == read_pos - *lineptr); if (nchars_avail < 1) { if (*n > MIN_CHUNK) *n *= 2; else *n += MIN_CHUNK; nchars_avail = *n + *lineptr - read_pos; *lineptr = xrealloc (*lineptr, *n); if (!*lineptr) return -1; read_pos = *n - nchars_avail + *lineptr; assert (*n - nchars_avail == read_pos - *lineptr); } if (feof (stream) || ferror (stream)) { /* Return partial line, if any. */ if (read_pos == *lineptr) return -1; else break; } *read_pos++ = c; nchars_avail--; if (c == terminator || c == '\n') /* Return the line. */ break; } /* Done - NUL terminate and return the number of chars read. */ *read_pos = '\0'; return read_pos - *lineptr; } static int print_kth (k) int k; { return ((eol_range_start > 0 && eol_range_start <= k) || (k <= max_range_endpoint && printable_field[k])); } /* Given the list of field or byte range specifications FIELDSTR, set MAX_RANGE_ENDPOINT and allocate and initialize the PRINTABLE_FIELD array. If there is a right-open-ended range, set EOL_RANGE_START to its starting index. FIELDSTR should be composed of one or more numbers or ranges of numbers, separated by blanks or commas. Incomplete ranges may be given: `-m' means `1-m'; `n-' means `n' through end of line. Return non-zero if FIELDSTR contains at least one field specification, zero otherwise. */ /* FIXME-someday: What if the user wants to cut out the 1,000,000-th field of some huge input file? This function shouldn't have to alloate a table of a million ints just so we can test every field < 10^6 with an array dereference. Instead, consider using a dynamic hash table. It would be simpler and nearly as good a solution to use a 32K x 4-byte table with one bit per field index instead of a whole `int' per index. */ static int set_fields (fieldstr) const char *fieldstr; { int initial = 1; /* Value of first number in a range. */ int dash_found = 0; /* Nonzero if a '-' is found in this field. */ int value = 0; /* If nonzero, a number being accumulated. */ int field_found = 0; /* Non-zero if at least one field spec has been processed. */ struct range_pair *rp; unsigned int n_rp; unsigned int n_rp_allocated; unsigned int i; n_rp = 0; n_rp_allocated = 16; rp = (struct range_pair *) xmalloc (n_rp_allocated * sizeof (*rp)); /* Collect and store in RP the range end points. It also sets EOL_RANGE_START if appropriate. */ for (;;) { if (*fieldstr == '-') { /* Starting a range. */ if (dash_found) FATAL_ERROR ("invalid byte or field list"); dash_found++; fieldstr++; if (value) { initial = value; value = 0; } else initial = 1; } else if (*fieldstr == ',' || ISBLANK (*fieldstr) || *fieldstr == '\0') { /* Ending the string, or this field/byte sublist. */ if (dash_found) { dash_found = 0; /* A range. Possibilites: -n, m-n, n-. In any case, `initial' contains the start of the range. */ if (value == 0) { /* `n-'. From `initial' to end of line. */ eol_range_start = initial; field_found = 1; } else { /* `m-n' or `-n' (1-n). */ if (value < initial) FATAL_ERROR ("invalid byte or field list"); /* Is there already a range going to end of line? */ if (eol_range_start != 0) { /* Yes. Is the new sequence already contained in the old one? If so, no processing is necessary. */ if (initial < eol_range_start) { /* No, the new sequence starts before the old. Does the old range going to end of line extend into the new range? */ if (value >= eol_range_start - 1) { /* Yes. Simply move the end of line marker. */ eol_range_start = initial; } else { /* No. A simple range, before and disjoint from the range going to end of line. Fill it. */ ADD_RANGE_PAIR (rp, initial, value); } /* In any case, some fields were selected. */ field_found = 1; } } else { /* There is no range going to end of line. */ ADD_RANGE_PAIR (rp, initial, value); field_found = 1; } value = 0; } } else if (value != 0) { /* A simple field number, not a range. */ ADD_RANGE_PAIR (rp, value, value); value = 0; field_found = 1; } if (*fieldstr == '\0') { break; } fieldstr++; } else if (ISDIGIT (*fieldstr)) { /* FIXME: detect overflow? */ value = 10 * value + *fieldstr - '0'; fieldstr++; } else FATAL_ERROR ("invalid byte or field list"); } max_range_endpoint = 0; for (i = 0; i < n_rp; i++) { if (rp[i].hi > max_range_endpoint) max_range_endpoint = rp[i].hi; } /* Allocate an array large enough so that it may be indexed by the field numbers corresponding to all finite ranges (i.e. `2-6' or `-4', but not `5-') in FIELDSTR. */ printable_field = (int *) xmalloc ((max_range_endpoint + 1) * sizeof (int)); for (i = 1; i <= max_range_endpoint; i++) printable_field[i] = 0; /* Set the array entries corresponding to integers in the ranges of RP. */ for (i = 0; i < n_rp; i++) { int j; for (j = rp[i].lo; j <= rp[i].hi; j++) { printable_field[j] = 1; } } free (rp); return field_found; } /* Read from stream STREAM, printing to standard output any selected bytes. */ static void cut_bytes (stream) FILE *stream; { int byte_idx; /* Number of chars in the line so far. */ byte_idx = 0; while (1) { register int c; /* Each character from the file. */ c = getc (stream); if (c == '\n') { putchar ('\n'); byte_idx = 0; } else if (c == EOF) { if (byte_idx > 0) putchar ('\n'); break; } else { ++byte_idx; if (print_kth (byte_idx)) { putchar (c); } } } } /* Read from stream STREAM, printing to standard output any selected fields. */ static void cut_fields (stream) FILE *stream; { int c; int field_idx; int found_any_selected_field; int buffer_first_field; found_any_selected_field = 0; field_idx = 1; /* To support the semantics of the -s flag, we may have to buffer all of the first field to determine whether it is `delimited.' But that is unnecessary if all non-delimited lines must be printed and the first field has been selected, or if non-delimited lines must be suppressed and the first field has *not* been selected. That is because a non-delimited line has exactly one field. */ buffer_first_field = (suppress_non_delimited ^ !print_kth (1)); while (1) { if (field_idx == 1 && buffer_first_field) { int len; len = getstr (&field_1_buffer, &field_1_bufsize, stream, delim); if (len < 0) break; assert (len != 0); /* If the first field extends to the end of line (it is not delimited) and we are printing all non-delimited lines, print this one. */ if (field_1_buffer[len - 1] != delim) { if (suppress_non_delimited) { /* Empty. */ } else { fwrite (field_1_buffer, sizeof (char), len, stdout); /* Make sure the output line is newline terminated. */ if (field_1_buffer[len - 1] != '\n') putchar ('\n'); } continue; } if (print_kth (1)) { /* Print the field, but not the trailing delimiter. */ fwrite (field_1_buffer, sizeof (char), len - 1, stdout); found_any_selected_field = 1; } ++field_idx; } if (print_kth (field_idx)) { if (found_any_selected_field) putchar (delim); found_any_selected_field = 1; while ((c = getc (stream)) != delim && c != '\n' && c != EOF) { putchar (c); } } else { while ((c = getc (stream)) != delim && c != '\n' && c != EOF) { /* Empty. */ } } if (c == '\n') { c = getc (stream); if (c != EOF) { ungetc (c, stream); c = '\n'; } } if (c == delim) ++field_idx; else if (c == '\n' || c == EOF) { if (found_any_selected_field || !(suppress_non_delimited && field_idx == 1)) putchar ('\n'); if (c == EOF) break; field_idx = 1; found_any_selected_field = 0; } } } static void cut_stream (stream) FILE *stream; { if (operating_mode == byte_mode) cut_bytes (stream); else cut_fields (stream); } /* Process file FILE to standard output. Return 0 if successful, 1 if not. */ static int cut_file (file) char *file; { FILE *stream; if (!strcmp (file, "-")) { have_read_stdin = 1; stream = stdin; } else { stream = fopen (file, "r"); if (stream == NULL) { error (0, errno, "%s", file); return 1; } } cut_stream (stream); if (ferror (stream)) { error (0, errno, "%s", file); return 1; } if (!strcmp (file, "-")) clearerr (stream); /* Also clear EOF. */ else if (fclose (stream) == EOF) { error (0, errno, "%s", file); return 1; } return 0; } void main (argc, argv) int argc; char **argv; { int optc, exit_status = 0; program_name = argv[0]; operating_mode = undefined_mode; /* By default, all non-delimited lines are printed. */ suppress_non_delimited = 0; delim = '\0'; have_read_stdin = 0; while ((optc = getopt_long (argc, argv, "b:c:d:f:ns", longopts, (int *) 0)) != EOF) { switch (optc) { case 0: break; case 'b': case 'c': /* Build the byte list. */ if (operating_mode != undefined_mode) FATAL_ERROR ("only one type of list may be specified"); operating_mode = byte_mode; if (set_fields (optarg) == 0) FATAL_ERROR ("missing list of positions"); break; case 'f': /* Build the field list. */ if (operating_mode != undefined_mode) FATAL_ERROR ("only one type of list may be specified"); operating_mode = field_mode; if (set_fields (optarg) == 0) FATAL_ERROR ("missing list of fields"); break; case 'd': /* New delimiter. */ /* Interpret -d '' to mean `use the NUL byte as the delimiter.' */ if (optarg[0] != '\0' && optarg[1] != '\0') FATAL_ERROR ("the delimiter must be a single character"); delim = optarg[0]; break; case 'n': break; case 's': suppress_non_delimited = 1; break; default: usage (2); } } if (show_version) { printf ("cut - %s\n", version_string); exit (0); } if (show_help) usage (0); if (operating_mode == undefined_mode) FATAL_ERROR ("you must specify a list of bytes, characters, or fields"); if (delim != '\0' && operating_mode != field_mode) FATAL_ERROR ("a delimiter may be specified only when operating on fields"); if (suppress_non_delimited && operating_mode != field_mode) FATAL_ERROR ("suppressing non-delimited lines makes sense\n\ \tonly when operating on fields"); if (delim == '\0') delim = '\t'; if (optind == argc) exit_status |= cut_file ("-"); else for (; optind < argc; optind++) exit_status |= cut_file (argv[optind]); if (have_read_stdin && fclose (stdin) == EOF) { error (0, errno, "-"); exit_status = 1; } if (ferror (stdout) || fclose (stdout) == EOF) error (1, errno, "write error"); exit (exit_status); } textutils-1.12/src/expand.c100666 74504 13 22327 5770310547 15034 0ustar meyeringuser/* expand - convert tabs to spaces Copyright (C) 1989, 1991, 1995 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* By default, convert all tabs to spaces. Preserves backspace characters in the output; they decrement the column count for tab calculations. The default action is equivalent to -8. Options: --tabs=tab1[,tab2[,...]] -t tab1[,tab2[,...]] -tab1[,tab2[,...]] If only one tab stop is given, set the tabs tab1 spaces apart instead of the default 8. Otherwise, set the tabs at columns tab1, tab2, etc. (numbered from 0); replace any tabs beyond the tabstops given with single spaces. --initial -i Only convert initial tabs on each line to spaces. David MacKenzie */ #include /* Get isblank from GNU libc. */ #define _GNU_SOURCE #include #include #include #include "system.h" #include "version.h" #include "error.h" /* The number of bytes added at a time to the amount of memory allocated for the output line. */ #define OUTPUT_BLOCK 256 /* The number of bytes added at a time to the amount of memory allocated for the list of tabstops. */ #define TABLIST_BLOCK 256 char *xmalloc (); char *xrealloc (); static FILE *next_file (); static void add_tabstop (); static void expand (); static void parse_tabstops (); static void usage (); static void validate_tabstops (); /* The name this program was run with. */ char *program_name; /* If nonzero, convert blanks even after nonblank characters have been read on the line. */ static int convert_entire_line; /* If nonzero, the size of all tab stops. If zero, use `tab_list' instead. */ static int tab_size; /* Array of the explicit column numbers of the tab stops; after `tab_list' is exhausted, each additional tab is replaced by a space. The first column is column 0. */ static int *tab_list; /* The index of the first invalid element of `tab_list', where the next element can be added. */ static int first_free_tab; /* Null-terminated array of input filenames. */ static char **file_list; /* Default for `file_list' if no files are given on the command line. */ static char *stdin_argv[] = { "-", NULL }; /* Nonzero if we have ever read standard input. */ static int have_read_stdin; /* Status to return to the system. */ static int exit_status; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output then exit. */ static int show_version; static struct option const longopts[] = { {"tabs", required_argument, NULL, 't'}, {"initial", no_argument, NULL, 'i'}, {"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 tabval = -1; /* Value of tabstop being read, or -1. */ int c; /* Option character. */ have_read_stdin = 0; exit_status = 0; convert_entire_line = 1; tab_list = NULL; first_free_tab = 0; program_name = argv[0]; while ((c = getopt_long (argc, argv, "it:,0123456789", longopts, (int *) 0)) != EOF) { switch (c) { case 0: break; case '?': usage (1); case 'i': convert_entire_line = 0; break; case 't': parse_tabstops (optarg); break; case ',': add_tabstop (tabval); tabval = -1; break; default: if (tabval == -1) tabval = 0; tabval = tabval * 10 + c - '0'; break; } } if (show_version) { printf ("expand - %s\n", version_string); exit (0); } if (show_help) usage (0); add_tabstop (tabval); validate_tabstops (tab_list, first_free_tab); if (first_free_tab == 0) tab_size = 8; else if (first_free_tab == 1) tab_size = tab_list[0]; else tab_size = 0; if (optind == argc) file_list = stdin_argv; else file_list = &argv[optind]; expand (); if (have_read_stdin && fclose (stdin) == EOF) error (1, errno, "-"); if (ferror (stdout) || fclose (stdout) == EOF) error (1, errno, "write error"); exit (exit_status); } /* Add the comma or blank separated list of tabstops STOPS to the list of tabstops. */ static void parse_tabstops (stops) char *stops; { int tabval = -1; for (; *stops; stops++) { if (*stops == ',' || ISBLANK (*stops)) { add_tabstop (tabval); tabval = -1; } else if (ISDIGIT (*stops)) { if (tabval == -1) tabval = 0; tabval = tabval * 10 + *stops - '0'; } else error (1, 0, "tab size contains an invalid character"); } add_tabstop (tabval); } /* Add tab stop TABVAL to the end of `tab_list', except if TABVAL is -1, do nothing. */ static void add_tabstop (tabval) int tabval; { if (tabval == -1) return; if (first_free_tab % TABLIST_BLOCK == 0) tab_list = (int *) xrealloc (tab_list, first_free_tab + TABLIST_BLOCK * sizeof (tab_list[0])); tab_list[first_free_tab++] = tabval; } /* Check that the list of tabstops TABS, with ENTRIES entries, contains only nonzero, ascending values. */ static void validate_tabstops (tabs, entries) int *tabs; int entries; { int prev_tab = 0; int i; for (i = 0; i < entries; i++) { if (tabs[i] == 0) error (1, 0, "tab size cannot be 0"); if (tabs[i] <= prev_tab) error (1, 0, "tab sizes must be ascending"); prev_tab = tabs[i]; } } /* Change tabs to spaces, writing to stdout. Read each file in `file_list', in order. */ static void expand () { FILE *fp; /* Input stream. */ int c; /* Each input character. */ int tab_index = 0; /* Index in `tab_list' of next tabstop. */ int column = 0; /* Column on screen of the next char. */ int next_tab_column; /* Column the next tab stop is on. */ int convert = 1; /* If nonzero, perform translations. */ fp = next_file ((FILE *) NULL); if (fp == NULL) return; for (;;) { c = getc (fp); if (c == EOF) { fp = next_file (fp); if (fp == NULL) break; /* No more files. */ else continue; } if (c == '\n') { putchar (c); tab_index = 0; column = 0; convert = 1; } else if (c == '\t' && convert) { if (tab_size == 0) { /* Do not let tab_index == first_free_tab; stop when it is 1 less. */ while (tab_index < first_free_tab - 1 && column >= tab_list[tab_index]) tab_index++; next_tab_column = tab_list[tab_index]; if (tab_index < first_free_tab - 1) tab_index++; if (column >= next_tab_column) next_tab_column = column + 1; /* Ran out of tab stops. */ } else { next_tab_column = column + tab_size - column % tab_size; } while (column < next_tab_column) { putchar (' '); ++column; } } else { if (convert) { if (c == '\b') { if (column > 0) --column; } else { ++column; if (convert_entire_line == 0) convert = 0; } } putchar (c); } } } /* Close the old stream pointer FP if it is non-NULL, and return a new one opened to read the next input file. Open a filename of `-' as the standard input. Return NULL if there are no more input files. */ static FILE * next_file (fp) FILE *fp; { static char *prev_file; char *file; if (fp) { if (ferror (fp)) { error (0, errno, "%s", prev_file); exit_status = 1; } if (fp == stdin) clearerr (fp); /* Also clear EOF. */ else if (fclose (fp) == EOF) { error (0, errno, "%s", prev_file); exit_status = 1; } } while ((file = *file_list++) != NULL) { if (file[0] == '-' && file[1] == '\0') { have_read_stdin = 1; prev_file = file; return stdin; } fp = fopen (file, "r"); if (fp) { prev_file = file; return fp; } error (0, errno, "%s", file); exit_status = 1; } return NULL; } 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 ("\ Convert tabs in each FILE to spaces, writing to standard output.\n\ With no FILE, or when FILE is -, read standard input.\n\ \n\ -i, --initial do not convert TABs after non whitespace\n\ -t, --tabs=NUMBER have tabs NUMBER characters apart, not 8\n\ -t, --tabs=LIST use comma separated list of explicit tab positions\n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ Instead of -t NUMBER or -t LIST, -NUMBER or -LIST may be used.\n\ "); } exit (status); } textutils-1.12/src/fmt.c100666 74504 13 60536 5770310557 14350 0ustar meyeringuser/* GNU fmt -- simple text formatter. Copyright (C) 1994, 1995 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* Written by Ross Paterson . */ #include #include #include #include #include "system.h" #include "version.h" #include "error.h" /* The following parameters represent the program's idea of what is "best". Adjust to taste, subject to the caveats given. */ /* Default longest permitted line length (max_width). */ #define WIDTH 75 /* Prefer lines to be LEEWAY % shorter than the maximum width, giving room for optimization. */ #define LEEWAY 7 /* The default secondary indent of tagged paragraph used for unindented one-line paragraphs not preceded by any multi-line paragraphs. */ #define DEF_INDENT 3 /* Costs and bonuses are expressed as the equivalent departure from the optimal line length, multiplied by 10. e.g. assigning something a cost of 50 means that it is as bad as a line 5 characters too short or too long. The definition of SHORT_COST(n) should not be changed. However, EQUIV(n) may need tuning. */ typedef long COST; #define MAXCOST (~(((COST) 1) << (8 * sizeof (COST) -1))) #define SQR(n) ((n) * (n)) #define EQUIV(n) SQR ((COST) (n)) /* Cost of a filled line n chars longer or shorter than best_width. */ #define SHORT_COST(n) EQUIV ((n) * 10) /* Cost of the difference between adjacent filled lines. */ #define RAGGED_COST(n) (SHORT_COST (n) / 2) /* Basic cost per line. */ #define LINE_COST EQUIV (70) /* Cost of breaking a line after the first word of a sentence, where the length of the word is N. */ #define WIDOW_COST(n) (EQUIV (200) / ((n) + 2)) /* Cost of breaking a line before the last word of a sentence, where the length of the word is N. */ #define ORPHAN_COST(n) (EQUIV (150) / ((n) + 2)) /* Bonus for breaking a line at the end of a sentence. */ #define SENTENCE_BONUS EQUIV (50) /* Cost of breaking a line after a period not marking end of a sentence. With the definition of sentence we are using (borrowed from emacs, see get_line()) such a break would then look like a sentence break. Hence we assign a very high cost -- it should be avoided unless things are really bad. */ #define NOBREAK_COST EQUIV (600) /* Bonus for breaking a line before open parenthesis. */ #define PAREN_BONUS EQUIV (40) /* Bonus for breaking a line after other punctuation. */ #define PUNCT_BONUS EQUIV(40) /* Credit for breaking a long paragraph one line later. */ #define LINE_CREDIT EQUIV(3) /* Size of paragraph buffer, in words and characters. Longer paragraphs are handled neatly (cf. flush_paragraph()), so there's little to gain by making these larger. */ #define MAXWORDS 1000 #define MAXCHARS 5000 /* Extra ctype(3)-style macros. */ #define isopen(c) (strchr ("([`'\"", c) != NULL) #define isclose(c) (strchr (")]'\"", c) != NULL) #define isperiod(c) (strchr (".?!", c) != NULL) /* Size of a tab stop, for expansion on input and re-introduction on output. */ #define TABWIDTH 8 /* Miscellaneous definitions. */ typedef unsigned int bool; #define TRUE 1 #define FALSE 0 /* Word descriptor structure. */ typedef struct Word WORD; struct Word { /* Static attributes determined during input. */ const char *text; /* the text of the word */ short length; /* length of this word */ short space; /* the size of the following space */ bool paren:1; /* starts with open paren */ bool period:1; /* ends in [.?!])* */ bool punct:1; /* ends in punctuation */ bool final:1; /* end of sentence */ /* The remaining fields are computed during the optimization. */ short line_length; /* length of the best line starting here */ COST best_cost; /* cost of best paragraph starting here */ WORD *next_break; /* break which achieves best_cost */ }; /* Forward declarations. */ /* My AC_PROTOTYPES would be better than __STDC__. FIXME :-). */ #if __STDC__ #define _(x) x #else #define _(x) () #endif static void set_prefix _ ((char *p)); static void fmt _ ((FILE *f)); static bool get_paragraph _ ((FILE *f)); static int get_line _ ((FILE *f, int c)); static int get_prefix _ ((FILE *f)); static int get_space _ ((FILE *f, int c)); static int copy_rest _ ((FILE *f, int c)); static bool same_para _ ((int c)); static void flush_paragraph _ ((void)); static void fmt_paragraph _ ((void)); static void check_punctuation _ ((WORD *w)); static COST base_cost _ ((WORD *this)); static COST line_cost _ ((WORD *next, int len)); static void put_paragraph _ ((WORD *finish)); static void put_line _ ((WORD *w, int indent)); static void put_word _ ((WORD *w)); static void put_space _ ((int space)); /* The name this program was run with. */ const char *program_name; /* If non-zero, display usage information and exit. */ static int show_help = 0; /* If non-zero, print the version on standard output and exit. */ static int show_version = 0; /* Option values. */ /* If TRUE, first 2 lines may have different indent (default FALSE). */ static bool crown; /* If TRUE, first 2 lines _must_ have different indent (default FALSE). */ static bool tagged; /* If TRUE, each line is a paragraph on its own (default FALSE). */ static bool split; /* If TRUE, don't preserve inter-word spacing (default FALSE). */ static bool uniform; /* Prefix minus leading and trailing spaces (default ""). */ static const char *prefix; /* User-supplied maximum line width (default WIDTH). The only output lines longer than this will each comprise a single word. */ static int max_width; /* Values derived from the option values. */ /* The length of prefix minus leading space. */ static int prefix_full_length; /* The length of the leading space trimmed from the prefix. */ static int prefix_lead_space; /* The length of prefix minus leading and trailing space. */ static int prefix_length; /* The preferred width of text lines, set to LEEWAY % less than max_width. */ static int best_width; /* Dynamic variables. */ /* Start column of the character most recently read from the input file. */ static int in_column; /* Start column of the next character to be written to stdout. */ static int out_column; /* Space for the paragraph text -- longer paragraphs are handled neatly (cf. flush_paragraph()). */ static char parabuf[MAXCHARS]; /* A pointer into parabuf, indicating the first unused character position. */ static char *wptr; /* The words of a paragraph -- longer paragraphs are handled neatly (cf. flush_paragraph()). */ static WORD word[MAXWORDS]; /* A pointer into the above word array, indicating the first position after the last complete word. Sometimes it will point at an incomplete word. */ static WORD *word_limit; /* If TRUE, current input file contains tab characters, and so tabs can be used for white space on output. */ static bool tabs; /* Space before trimmed prefix on each line of the current paragraph. */ static int prefix_indent; /* Indentation of the first line of the current paragraph. */ static int first_indent; /* Indentation of other lines of the current paragraph */ static int other_indent; /* To detect the end of a paragraph, we need to look ahead to the first non-blank character after the prefix on the next line, or the first character on the following line that failed to match the prefix. We can reconstruct the lookahead from that character (next_char), its position on the line (in_column) and the amount of space before the prefix (next_prefix_indent). See get_paragraph() and copy_rest(). */ /* The last character read from the input file. */ static int next_char; /* The space before the trimmed prefix (or part of it) on the next line after the current paragraph. */ static int next_prefix_indent; /* If non-zero, the length of the last line output in the current paragraph, used to charge for raggedness at the split point for long paragraphs chosen by fmt_paragraph(). */ static int last_line_length; static void usage (status) int status; { if (status != 0) fprintf (stderr, "Try `%s --help' for more information.\n", program_name); else { printf ("Usage: %s [-DIGITS] [OPTION]... [FILE]...\n", program_name); fputs ("\ Reformat each paragraph in the FILE(s), writing to standard output.\n\ If no FILE or if FILE is `-', read standard input.\n\ \n\ Mandatory arguments to long options are mandatory for short options too.\n\ -c, --crown-margin preserve indentation of first two lines\n\ -s, --split-only split long lines, but do not refill\n\ -t, --tagged-paragraph indentation of first line different from second\n\ -u, --uniform-spacing one space between words, two after sentences\n\ -w, --width=NUMBER maximum line width (default of 75 columns)\n\ -p, --prefix=STRING combine only lines having STRING as prefix\n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ In -wNUMBER, the letter `w' may be omitted.\n", stdout); } exit (status); } /* Decode options and launch execution. */ static const struct option long_options[] = { {"crown-margin", no_argument, NULL, 'c'}, {"help", no_argument, &show_help, 1}, {"prefix", required_argument, NULL, 'p'}, {"split-only", no_argument, NULL, 's'}, {"tagged-paragraph", no_argument, NULL, 't'}, {"uniform-spacing", no_argument, NULL, 'u'}, {"version", no_argument, &show_version, 1}, {"width", required_argument, NULL, 'w'}, {0, 0, 0, 0}, }; int main (argc, argv) register int argc; register char *argv[]; { int optchar; FILE *infile; program_name = argv[0]; crown = tagged = split = uniform = FALSE; max_width = WIDTH; prefix = ""; prefix_length = prefix_lead_space = prefix_full_length = 0; if (argc > 1 && argv[1][0] == '-' && ISDIGIT (argv[1][1])) { max_width = 0; /* Old option syntax; a dash followed by one or more digits. Move past the number. */ for (++argv[1]; ISDIGIT (*argv[1]); ++argv[1]) { /* FIXME: use strtol to detect overflow. */ max_width = max_width * 10 + *argv[1] - '0'; } /* Make the options we just parsed invisible to getopt. */ argv[1] = argv[0]; argv++; argc--; } while ((optchar = getopt_long (argc, argv, "0123456789cstuw:p:", long_options, NULL)) != EOF) switch (optchar) { default: usage (1); case 0: break; case 'c': crown = TRUE; break; case 's': split = TRUE; break; case 't': tagged = TRUE; break; case 'u': uniform = TRUE; break; case 'w': /* FIXME: use strtol. */ max_width = atoi (optarg); break; case 'p': set_prefix (optarg); break; } if (show_version) { printf ("fmt - %s\n", version_string); exit (0); } if (show_help) usage (0); best_width = max_width * (2 * (100 - LEEWAY) + 1) / 200; if (optind == argc) fmt (stdin); else for (; optind < argc; optind++) if (strcmp (argv[optind], "-") == 0) fmt (stdin); else { infile = fopen (argv[optind], "r"); if (infile != NULL) { fmt (infile); fclose (infile); } else error (0, errno, argv[optind]); } exit (0); } /* Trim space from the front and back of the string P, yielding the prefix, and record the lengths of the prefix and the space trimmed. */ static void set_prefix (p) register char *p; { register char *s; prefix_lead_space = 0; while (*p == ' ') { prefix_lead_space++; p++; } prefix = p; prefix_full_length = strlen (p); s = p + prefix_full_length; while (s > p && s[-1] == ' ') s--; *s = '\0'; prefix_length = s - p; } /* read file F and send formatted output to stdout. */ static void fmt (f) FILE *f; { tabs = FALSE; other_indent = 0; next_char = get_prefix (f); while (get_paragraph (f)) { fmt_paragraph (); put_paragraph (word_limit); } } /* Read a paragraph from input file F. A paragraph consists of a maximal number of non-blank (excluding any prefix) lines subject to: * In split mode, a paragraph is a single non-blank line. * In crown mode, the second and subsequent lines must have the same indentation, but possibly different from the indent of the first line. * Tagged mode is similar, but the first and second lines must have different indentations. * Otherwise, all lines of a paragraph must have the same indent. If a prefix is in effect, it must be present at the same indent for each line in the paragraph. Return FALSE if end-of-file was encountered before the start of a paragraph, else TRUE. */ static bool get_paragraph (f) FILE *f; { register int c; last_line_length = 0; c = next_char; /* Scan (and copy) blank lines, and lines not introduced by the prefix. */ while (c == '\n' || c == EOF || next_prefix_indent < prefix_lead_space || in_column < next_prefix_indent + prefix_full_length) { c = copy_rest (f, c); if (c == EOF) { next_char = EOF; return FALSE; } putchar ('\n'); c = get_prefix (f); } /* Got a suitable first line for a paragraph. */ prefix_indent = next_prefix_indent; first_indent = in_column; wptr = parabuf; word_limit = word; c = get_line (f, c); /* Read rest of paragraph (unless split is specified). */ if (split) other_indent = first_indent; else if (crown) { if (same_para (c)) { other_indent = in_column; do { /* for each line till the end of the para */ c = get_line (f, c); } while (same_para (c) && in_column == other_indent); } else other_indent = first_indent; } else if (tagged) { if (same_para (c) && in_column != first_indent) { other_indent = in_column; do { /* for each line till the end of the para */ c = get_line (f, c); } while (same_para (c) && in_column == other_indent); } /* Only one line: use the secondary indent from last time if it splits, or 0 if there have been no multi-line paragraphs in the input so far. But if these rules make the two indents the same, pick a new secondary indent. */ else if (other_indent == first_indent) other_indent = first_indent == 0 ? DEF_INDENT : 0; } else { other_indent = first_indent; while (same_para (c) && in_column == other_indent) c = get_line (f, c); } (word_limit - 1)->period = (word_limit - 1)->final = TRUE; next_char = c; return TRUE; } /* Copy to the output a line that failed to match the prefix, or that was blank after the prefix. In the former case, C is the character that failed to match the prefix. In the latter, C is \n or EOF. Return the character (\n or EOF) ending the line. */ static int copy_rest (f, c) FILE *f; register int c; { register const char *s; out_column = 0; if (in_column > next_prefix_indent && c != '\n' && c != EOF) { put_space (next_prefix_indent); for (s = prefix; out_column != in_column; out_column++) putchar (*s++); } while (c != '\n' && c != EOF) { putchar (c); c = getc (f); } return c; } /* Return TRUE if a line whose first non-blank character after the prefix (if any) is C could belong to the current paragraph, otherwise FALSE. */ static bool same_para (c) register int c; { return (next_prefix_indent == prefix_indent && in_column >= next_prefix_indent + prefix_full_length && c != '\n' && c != EOF); } /* Read a line from input file F, given first non-blank character C after the prefix, and the following indent, and break it into words. A word is a maximal non-empty string of non-white characters. A word ending in [.?!]["')\]]* and followed by end-of-line or at least two spaces ends a sentence, as in emacs. Return the first non-blank character of the next line. */ static int get_line (f, c) FILE *f; register int c; { int start; register char *end_of_parabuf; register WORD *end_of_word; end_of_parabuf = ¶buf[MAXCHARS]; end_of_word = &word[MAXWORDS - 2]; do { /* for each word in a line */ /* Scan word. */ word_limit->text = wptr; do { if (wptr == end_of_parabuf) flush_paragraph (); *wptr++ = c; c = getc (f); } while (c != EOF && !isspace (c)); in_column += word_limit->length = wptr - word_limit->text; check_punctuation (word_limit); /* Scan inter-word space. */ start = in_column; c = get_space (f, c); word_limit->space = in_column - start; word_limit->final = (c == EOF || (word_limit->period && (c == '\n' || word_limit->space > 1))); if (c == '\n' || c == EOF || uniform) word_limit->space = word_limit->final ? 2 : 1; if (word_limit == end_of_word) flush_paragraph (); word_limit++; if (c == EOF) return EOF; } while (c != '\n'); return get_prefix (f); } /* Read a prefix from input file F. Return either first non-matching character, or first non-blank character after the prefix. */ static int get_prefix (f) FILE *f; { register int c; register const char *p; in_column = 0; c = get_space (f, getc (f)); if (prefix_length == 0) next_prefix_indent = prefix_lead_space < in_column ? prefix_lead_space : in_column; else { next_prefix_indent = in_column; for (p = prefix; *p != '\0'; p++) { if (c != *p) return c; in_column++; c = getc (f); } c = get_space (f, c); } return c; } /* Read blank characters from input file F, starting with C, and keeping in_column up-to-date. Return first non-blank character. */ static int get_space (f, c) FILE *f; register int c; { for (;;) { if (c == ' ') in_column++; else if (c == '\t') { tabs = TRUE; in_column = (in_column / TABWIDTH + 1) * TABWIDTH; } else return c; c = getc (f); } } /* Set extra fields in word W describing any attached punctuation. */ static void check_punctuation (w) register WORD *w; { register const char *start, *finish; start = w->text; finish = start + (w->length - 1); w->paren = isopen (*start); w->punct = ispunct (*finish); while (isclose (*finish) && finish > start) finish--; w->period = isperiod (*finish); } /* Flush part of the paragraph to make room. This function is called on hitting the limit on the number of words or characters. */ static void flush_paragraph () { WORD *split_point; register WORD *w; int shift; COST best_break; /* In the special case where it's all one word, just flush it. */ if (word_limit == word) { printf ("%*s", wptr - parabuf, parabuf); wptr = parabuf; return; } /* Otherwise: - format what you have so far as a paragraph, - find a low-cost line break near the end, - output to there, - make that the start of the paragraph. */ fmt_paragraph (); /* Choose a good split point. */ split_point = word_limit; best_break = MAXCOST; for (w = word->next_break; w != word_limit; w = w->next_break) { if (w->best_cost - w->next_break->best_cost < best_break) { split_point = w; best_break = w->best_cost - w->next_break->best_cost; } if (best_break <= MAXCOST - LINE_CREDIT) best_break += LINE_CREDIT; } put_paragraph (split_point); /* Copy text of words down to start of parabuf -- we use memmove because the source and target may overlap. */ memmove (parabuf, split_point->text, (size_t) (wptr - split_point->text)); shift = split_point->text - parabuf; wptr -= shift; /* Adjust text pointers. */ for (w = split_point; w <= word_limit; w++) w->text -= shift; /* Copy words from split_point down to word -- we use memmove because the source and target may overlap. */ memmove ((char *) word, (char *) split_point, (word_limit - split_point + 1) * sizeof (WORD)); word_limit -= split_point - word; } /* Compute the optimal formatting for the whole paragraph by computing and remembering the optimal formatting for each suffix from the empty one to the whole paragraph. */ static void fmt_paragraph () { register WORD *start, *w; register int len; register COST wcost, best; int saved_length; word_limit->best_cost = 0; saved_length = word_limit->length; word_limit->length = max_width; /* sentinel */ for (start = word_limit - 1; start >= word; start--) { best = MAXCOST; len = start == word ? first_indent : other_indent; /* At least one word, however long, in the line. */ w = start; len += w->length; do { w++; /* Consider breaking before w. */ wcost = line_cost (w, len) + w->best_cost; if (start == word && last_line_length > 0) wcost += RAGGED_COST (len - last_line_length); if (wcost < best) { best = wcost; start->next_break = w; start->line_length = len; } len += (w - 1)->space + w->length; /* w > start >= word */ } while (len < max_width); start->best_cost = best + base_cost (start); } word_limit->length = saved_length; } /* Return the constant component of the cost of breaking before the word THIS. */ static COST base_cost (this) register WORD *this; { register COST cost; cost = LINE_COST; if (this > word) { if ((this - 1)->period) { if ((this - 1)->final) cost -= SENTENCE_BONUS; else cost += NOBREAK_COST; } else if ((this - 1)->punct) cost -= PUNCT_BONUS; else if (this > word + 1 && (this - 2)->final) cost += WIDOW_COST ((this - 1)->length); } if (this->paren) cost -= PAREN_BONUS; else if (this->final) cost += ORPHAN_COST (this->length); return cost; } /* Return the component of the cost of breaking before word NEXT that depends on LEN, the length of the line beginning there. */ static COST line_cost (next, len) register WORD *next; register int len; { register int n; register COST cost; if (next == word_limit) return 0; n = best_width - len; cost = SHORT_COST (n); if (next->next_break != word_limit) { n = len - next->line_length; cost += RAGGED_COST (n); } return cost; } /* Output to stdout a paragraph from word up to (but not including) FINISH, which must be in the next_break chain from word. */ static void put_paragraph (finish) register WORD *finish; { register WORD *w; put_line (word, first_indent); for (w = word->next_break; w != finish; w = w->next_break) put_line (w, other_indent); } /* Output to stdout the line beginning with word W, beginning in column INDENT, including the prefix (if any). */ static void put_line (w, indent) register WORD *w; int indent; { register WORD *endline; out_column = 0; put_space (prefix_indent); fputs (prefix, stdout); out_column += prefix_length; put_space (indent - out_column); endline = w->next_break - 1; for (; w != endline; w++) { put_word (w); put_space (w->space); } put_word (w); last_line_length = out_column; putchar ('\n'); } /* Output to stdout the word W. */ static void put_word (w) register WORD *w; { register const char *s; register int n; s = w->text; for (n = w->length; n != 0; n--) putchar (*s++); out_column += w->length; } /* Output to stdout SPACE spaces, or equivalent tabs. */ static void put_space (space) int space; { register int space_target, tab_target; space_target = out_column + space; if (tabs) { tab_target = space_target / TABWIDTH * TABWIDTH; if (out_column + 1 < tab_target) while (out_column < tab_target) { putchar ('\t'); out_column = (out_column / TABWIDTH + 1) * TABWIDTH; } } while (out_column < space_target) { putchar (' '); out_column++; } } textutils-1.12/src/fold.c100666 74504 13 15660 5770310563 14501 0ustar meyeringuser/* fold -- wrap each input line to fit in specified width. Copyright (C) 1991, 1995 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* Written by David MacKenzie, djm@gnu.ai.mit.edu. */ #include /* Get isblank from GNU libc. */ #define _GNU_SOURCE #include #include #include #include "system.h" #include "version.h" #include "error.h" char *xrealloc (); char *xmalloc (); /* The name this program was run with. */ char *program_name; static int adjust_column (); static int fold_file (); /* If nonzero, try to break on whitespace. */ static int break_spaces; /* If nonzero, count bytes, not column positions. */ static int count_bytes; /* If nonzero, at least one of the files we read was standard input. */ static int have_read_stdin; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output then exit. */ static int show_version; static struct option const longopts[] = { {"bytes", no_argument, NULL, 'b'}, {"spaces", no_argument, NULL, 's'}, {"width", required_argument, NULL, 'w'}, {"help", no_argument, &show_help, 1}, {"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 ("\ Wrap input lines in each FILE (standard input by default), writing to\n\ standard output.\n\ \n\ -b, --bytes count bytes rather than columns\n\ -s, --spaces break at word boundaries\n\ -w, --width=WIDTH use WIDTH columns instead of 80\n\ "); } exit (status); } void main (argc, argv) int argc; char **argv; { int width = 80; int i; int optc; int errs = 0; program_name = argv[0]; break_spaces = count_bytes = have_read_stdin = 0; /* Turn any numeric options into -w options. */ for (i = 1; i < argc; i++) { if (argv[i][0] == '-' && ISDIGIT (argv[i][1])) { char *s; s = xmalloc (strlen (argv[i]) + 2); s[0] = '-'; s[1] = 'w'; strcpy (s + 2, argv[i] + 1); argv[i] = s; } } while ((optc = getopt_long (argc, argv, "bsw:", longopts, (int *) 0)) != EOF) { switch (optc) { case 0: break; case 'b': /* Count bytes rather than columns. */ count_bytes = 1; break; case 's': /* Break at word boundaries. */ break_spaces = 1; break; case 'w': /* Line width. */ width = atoi (optarg); if (width < 1) error (1, 0, "%s: invalid line width", optarg); break; default: usage (1); } } if (show_version) { printf ("fold - %s\n", version_string); exit (0); } if (show_help) usage (0); if (argc == optind) errs |= fold_file ("-", width); else for (i = optind; i < argc; i++) errs |= fold_file (argv[i], width); if (have_read_stdin && fclose (stdin) == EOF) error (1, errno, "-"); if (fclose (stdout) == EOF) error (1, errno, "write error"); exit (errs); } /* Fold file FILENAME, or standard input if FILENAME is "-", to stdout, with maximum line length WIDTH. Return 0 if successful, 1 if an error occurs. */ static int fold_file (filename, width) char *filename; int width; { FILE *istream; register int c; int column = 0; /* Screen column where next char will go. */ size_t offset_out = 0; /* Index in `line_out' for next char. */ static char *line_out = NULL; static size_t allocated_out = 0; if (!strcmp (filename, "-")) { istream = stdin; have_read_stdin = 1; } else istream = fopen (filename, "r"); if (istream == NULL) { error (0, errno, "%s", filename); return 1; } while ((c = getc (istream)) != EOF) { if (offset_out + 1 >= allocated_out) { allocated_out += 1024; line_out = xrealloc (line_out, allocated_out); } if (c == '\n') { line_out[offset_out++] = c; fwrite (line_out, sizeof (char), offset_out, stdout); column = offset_out = 0; continue; } rescan: column = adjust_column (column, c); if (column > width) { /* This character would make the line too long. Print the line plus a newline, and make this character start the next line. */ if (break_spaces) { /* Look for the last blank. */ int logical_end; for (logical_end = offset_out - 1; logical_end >= 0; logical_end--) if (ISBLANK (line_out[logical_end])) break; if (logical_end >= 0) { int i; /* Found a blank. Don't output the part after it. */ logical_end++; fwrite (line_out, sizeof (char), logical_end, stdout); putchar ('\n'); /* Move the remainder to the beginning of the next line. The areas being copied here might overlap. */ memmove (line_out, line_out + logical_end, offset_out - logical_end); offset_out -= logical_end; for (column = i = 0; i < offset_out; i++) column = adjust_column (column, line_out[i]); goto rescan; } } else { if (offset_out == 0) { line_out[offset_out++] = c; continue; } } line_out[offset_out++] = '\n'; fwrite (line_out, sizeof (char), offset_out, stdout); column = offset_out = 0; goto rescan; } line_out[offset_out++] = c; } if (offset_out) fwrite (line_out, sizeof (char), offset_out, stdout); if (ferror (istream)) { error (0, errno, "%s", filename); if (strcmp (filename, "-")) fclose (istream); return 1; } if (strcmp (filename, "-") && fclose (istream) == EOF) { error (0, errno, "%s", filename); return 1; } if (ferror (stdout)) { error (0, errno, "write error"); return 1; } return 0; } /* Assuming the current column is COLUMN, return the column that printing C will move the cursor to. The first column is 0. */ static int adjust_column (column, c) int column; char c; { if (!count_bytes) { if (c == '\b') { if (column > 0) column--; } else if (c == '\r') column = 0; else if (c == '\t') column = column + 8 - column % 8; else /* if (isprint (c)) */ column++; } else column++; return column; } textutils-1.12/src/head.c100666 74504 13 21353 5770310572 14452 0ustar meyeringuser/* head -- output first part of file(s) Copyright (C) 1989, 1990, 1991, 1995 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* Options: (see usage) Reads from standard input if no files are given or when a filename of ``-'' is encountered. By default, filename headers are printed only if more than one file is given. By default, prints the first 10 lines (head -n 10). David MacKenzie */ #include #include #include #include #include "system.h" #include "version.h" #include "error.h" /* Number of lines/chars/blocks to head. */ #define DEFAULT_NUMBER 10 /* Size of atomic reads. */ #define BUFSIZE (512 * 8) /* Number of bytes per item we are printing. If 0, head in lines. */ static int unit_size; /* If nonzero, print filename headers. */ static int print_headers; /* When to print the filename banners. */ enum header_mode { multiple_files, always, never }; int safe_read (); static int head (); static int head_bytes (); static int head_file (); static int head_lines (); static long atou (); static void parse_unit (); static void usage (); static void write_header (); /* The name this program was run with. */ char *program_name; /* Have we ever read standard input? */ static int have_read_stdin; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output then exit. */ static int show_version; static struct option const long_options[] = { {"bytes", required_argument, NULL, 'c'}, {"lines", required_argument, NULL, 'n'}, {"quiet", no_argument, NULL, 'q'}, {"silent", no_argument, NULL, 'q'}, {"verbose", no_argument, NULL, 'v'}, {"help", no_argument, &show_help, 1}, {"version", no_argument, &show_version, 1}, {NULL, 0, NULL, 0} }; void main (argc, argv) int argc; char **argv; { enum header_mode header_mode = multiple_files; int exit_status = 0; long number = -1; /* Number of items to print (-1 if undef.). */ int c; /* Option character. */ program_name = argv[0]; have_read_stdin = 0; unit_size = 0; print_headers = 0; if (argc > 1 && argv[1][0] == '-' && ISDIGIT (argv[1][1])) { /* Old option syntax; a dash, one or more digits, and one or more option letters. Move past the number. */ for (number = 0, ++argv[1]; ISDIGIT (*argv[1]); ++argv[1]) number = number * 10 + *argv[1] - '0'; /* Parse any appended option letters. */ while (*argv[1]) { switch (*argv[1]) { case 'b': unit_size = 512; break; case 'c': unit_size = 1; break; case 'k': unit_size = 1024; break; case 'l': unit_size = 0; break; case 'm': unit_size = 1048576; break; case 'q': header_mode = never; break; case 'v': header_mode = always; break; default: error (0, 0, "unrecognized option `-%c'", *argv[1]); usage (1); } ++argv[1]; } /* Make the options we just parsed invisible to getopt. */ argv[1] = argv[0]; argv++; argc--; } while ((c = getopt_long (argc, argv, "c:n:qv", long_options, (int *) 0)) != EOF) { switch (c) { case 0: break; case 'c': unit_size = 1; parse_unit (optarg); goto getnum; case 'n': unit_size = 0; getnum: number = atou (optarg); if (number == -1) error (1, 0, "invalid number `%s'", optarg); break; case 'q': header_mode = never; break; case 'v': header_mode = always; break; default: usage (1); } } if (show_version) { printf ("head - %s\n", version_string); exit (0); } if (show_help) usage (0); if (number == -1) number = DEFAULT_NUMBER; if (unit_size > 1) number *= unit_size; if (header_mode == always || (header_mode == multiple_files && optind < argc - 1)) print_headers = 1; if (optind == argc) exit_status |= head_file ("-", number); for (; optind < argc; ++optind) exit_status |= head_file (argv[optind], number); if (have_read_stdin && close (0) < 0) error (1, errno, "-"); if (fclose (stdout) == EOF) error (1, errno, "write error"); exit (exit_status); } static int head_file (filename, number) char *filename; long number; { int fd; if (!strcmp (filename, "-")) { have_read_stdin = 1; filename = "standard input"; if (print_headers) write_header (filename); return head (filename, 0, number); } else { fd = open (filename, O_RDONLY); if (fd >= 0) { int errors; if (print_headers) write_header (filename); errors = head (filename, fd, number); if (close (fd) == 0) return errors; } error (0, errno, "%s", filename); return 1; } } static void write_header (filename) char *filename; { static int first_file = 1; printf ("%s==> %s <==\n", (first_file ? "" : "\n"), filename); first_file = 0; } static int head (filename, fd, number) char *filename; int fd; long number; { if (unit_size) return head_bytes (filename, fd, number); else return head_lines (filename, fd, number); } static int head_bytes (filename, fd, bytes_to_write) char *filename; int fd; long bytes_to_write; { char buffer[BUFSIZE]; int bytes_read; while (bytes_to_write) { bytes_read = safe_read (fd, buffer, BUFSIZE); if (bytes_read < 0) { error (0, errno, "%s", filename); return 1; } if (bytes_read == 0) break; if (bytes_read > bytes_to_write) bytes_read = bytes_to_write; if (fwrite (buffer, 1, bytes_read, stdout) == 0) error (1, errno, "write error"); bytes_to_write -= bytes_read; } return 0; } static int head_lines (filename, fd, lines_to_write) char *filename; int fd; long lines_to_write; { char buffer[BUFSIZE]; int bytes_read; int bytes_to_write; while (lines_to_write) { bytes_read = safe_read (fd, buffer, BUFSIZE); if (bytes_read < 0) { error (0, errno, "%s", filename); return 1; } if (bytes_read == 0) break; bytes_to_write = 0; while (bytes_to_write < bytes_read) if (buffer[bytes_to_write++] == '\n' && --lines_to_write == 0) break; if (fwrite (buffer, 1, bytes_to_write, stdout) == 0) error (1, errno, "write error"); } return 0; } static void parse_unit (str) char *str; { int arglen = strlen (str); if (arglen == 0) return; switch (str[arglen - 1]) { case 'b': unit_size = 512; str[arglen - 1] = '\0'; break; case 'k': unit_size = 1024; str[arglen - 1] = '\0'; break; case 'm': unit_size = 1048576; str[arglen - 1] = '\0'; break; } } /* Convert STR, a string of ASCII digits, into an unsigned integer. Return -1 if STR does not represent a valid unsigned integer. */ static long atou (str) char *str; { int value; for (value = 0; ISDIGIT (*str); ++str) value = value * 10 + *str - '0'; return *str ? -1 : value; } 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 ("\ Print first 10 lines of each FILE to standard output.\n\ With more than one FILE, precede each with a header giving the file name.\n\ With no FILE, or when FILE is -, read standard input.\n\ \n\ -c, --bytes=SIZE print first SIZE bytes\n\ -n, --lines=NUMBER print first NUMBER lines instead of first 10\n\ -q, --quiet, --silent never print headers giving file names\n\ -v, --verbose always print headers giving file names\n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ SIZE may have a multiplier suffix: b for 512, k for 1K, m for 1 Meg.\n\ If -VALUE is used as first OPTION, read -c VALUE when one of\n\ multipliers bkm follows concatenated, else read -n VALUE.\n\ "); } exit (status); } textutils-1.12/src/join.c100666 74504 13 41270 5770310576 14514 0ustar meyeringuser/* join - join lines of two files on a common field Copyright (C) 1991, 1995 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. Written by Mike Haertel, mike@gnu.ai.mit.edu. */ #include /* Get isblank from GNU libc. */ #define _GNU_SOURCE #include #include #include #include "system.h" #include "version.h" #include "long-options.h" #include "error.h" char *xmalloc (); char *xrealloc (); static void usage (); #define min(A, B) ((A) < (B) ? (A) : (B)) #define max(A, B) ((A) > (B) ? (A) : (B)) /* An element of the list describing the format of each output line. */ struct outlist { int file; /* File to take field from (1 or 2). */ int field; /* Field number to print. */ struct outlist *next; }; /* A field of a line. */ struct field { const char *beg; /* First character in field. */ size_t len; /* The length of the field. */ }; /* A line read from an input file. Newlines are not stored. */ struct line { char *beg; /* First character in line. */ char *lim; /* Character after last character in line. */ int nfields; /* Number of elements in `fields'. */ int nfields_allocated; /* Number of elements in `fields'. */ struct field *fields; }; /* One or more consecutive lines read from a file that all have the same join field value. */ struct seq { int count; /* Elements used in `lines'. */ int alloc; /* Elements allocated in `lines'. */ struct line *lines; }; /* The name this program was run with. */ char *program_name; /* If nonzero, print unpairable lines in file 1 or 2. */ static int print_unpairables_1, print_unpairables_2; /* If nonzero, print pairable lines. */ static int print_pairables; /* Empty output field filler. */ static char *empty_filler; /* Field to join on. */ static int join_field_1, join_field_2; /* List of fields to print. */ static struct outlist *outlist; /* Last element in `outlist', where a new element can be added. */ static struct outlist *outlist_end; /* Tab character separating fields; if this is NUL fields are separated by any nonempty string of white space, otherwise by exactly one tab character. */ static char tab; /* When using getopt_long_only, no long option can start with a character that is a short option. */ static struct option const longopts[] = { {"j", required_argument, NULL, 'j'}, {"j1", required_argument, NULL, '1'}, {"j2", required_argument, NULL, '2'}, {NULL, 0, NULL, 0} }; /* Used to print non-joining lines */ static struct line uni_blank; static void ADD_FIELD (line, field, len) struct line *line; const char *field; size_t len; { if (line->nfields >= line->nfields_allocated) { line->nfields_allocated = (3 * line->nfields_allocated) / 2 + 1; line->fields = (struct field *) xrealloc ((char *) line->fields, (line->nfields_allocated * sizeof (struct field))); } line->fields[line->nfields].beg = field; line->fields[line->nfields].len = len; ++(line->nfields); } /* Fill in the `fields' structure in LINE. */ static void xfields (line) struct line *line; { int i; register char *ptr, *lim; ptr = line->beg; lim = line->lim; for (i = 0; ptr < lim; ++i) { if (tab) { char *beg; beg = ptr; while (ptr < lim && *ptr != tab) ++ptr; ADD_FIELD (line, beg, ptr - beg); if (ptr < lim) ++ptr; } else { char *beg; beg = ptr; while (ptr < lim && !ISSPACE (*ptr)) ++ptr; ADD_FIELD (line, beg, ptr - beg); while (ptr < lim && ISSPACE (*ptr)) ++ptr; } } if (ptr > line->beg && ((tab && ISSPACE (ptr[-1])) || ptr[-1] == tab)) { /* Add one more (empty) field because the last character of the line was a delimiter. */ ADD_FIELD (line, NULL, 0); } } /* Read a line from FP into LINE and split it into fields. Return 0 if EOF, 1 otherwise. */ static int get_line (fp, line) FILE *fp; struct line *line; { static int linesize = 80; int c, i; char *ptr; if (feof (fp)) return 0; ptr = xmalloc (linesize); for (i = 0; (c = getc (fp)) != EOF && c != '\n'; ++i) { if (i == linesize) { linesize *= 2; ptr = xrealloc (ptr, linesize); } ptr[i] = c; } if (c == EOF && i == 0) { free (ptr); return 0; } line->beg = ptr; line->lim = line->beg + i; line->nfields_allocated = 0; line->nfields = 0; line->fields = NULL; xfields (line); return 1; } static void freeline (line) struct line *line; { free ((char *) line->fields); free (line->beg); line->beg = NULL; } static void initseq (seq) struct seq *seq; { seq->count = 0; seq->alloc = 1; seq->lines = (struct line *) xmalloc (seq->alloc * sizeof (struct line)); } /* Read a line from FP and add it to SEQ. Return 0 if EOF, 1 otherwise. */ static int getseq (fp, seq) FILE *fp; struct seq *seq; { if (seq->count == seq->alloc) { seq->alloc *= 2; seq->lines = (struct line *) xrealloc ((char *) seq->lines, seq->alloc * sizeof (struct line)); } if (get_line (fp, &seq->lines[seq->count])) { ++seq->count; return 1; } return 0; } static void delseq (seq) struct seq *seq; { int i; for (i = 0; i < seq->count; i++) if (seq->lines[i].beg) freeline (&seq->lines[i]); free ((char *) seq->lines); } /* Return <0 if the join field in LINE1 compares less than the one in LINE2; >0 if it compares greater; 0 if it compares equal. */ static int keycmp (line1, line2) struct line *line1; struct line *line2; { const char *beg1, *beg2; /* Start of field to compare in each file. */ int len1, len2; /* Length of fields to compare. */ int diff; if (join_field_1 < line1->nfields) { beg1 = line1->fields[join_field_1].beg; len1 = line1->fields[join_field_1].len; } else { beg1 = NULL; len1 = 0; } if (join_field_2 < line2->nfields) { beg2 = line2->fields[join_field_2].beg; len2 = line2->fields[join_field_2].len; } else { beg2 = NULL; len2 = 0; } if (len1 == 0) return len2 == 0 ? 0 : -1; if (len2 == 0) return 1; diff = memcmp (beg1, beg2, min (len1, len2)); if (diff) return diff; return len1 - len2; } /* Print field N of LINE if it exists and is nonempty, otherwise `empty_filler' if it is nonempty. */ static void prfield (n, line) int n; struct line *line; { int len; if (n < line->nfields) { len = line->fields[n].len; if (len) fwrite (line->fields[n].beg, 1, len, stdout); else if (empty_filler) fputs (empty_filler, stdout); } else if (empty_filler) fputs (empty_filler, stdout); } /* Print the join of LINE1 and LINE2. */ static void prjoin (line1, line2) struct line *line1; struct line *line2; { if (outlist) { struct outlist *o; prfield (outlist->field - 1, outlist->file == 1 ? line1 : line2); for (o = outlist->next; o; o = o->next) { putchar (tab ? tab : ' '); prfield (o->field - 1, o->file == 1 ? line1 : line2); } putchar ('\n'); } else { int i; if (line1 == &uni_blank) { struct line *t; t = line1; line1 = line2; line2 = t; } prfield (join_field_1, line1); for (i = 0; i < join_field_1 && i < line1->nfields; ++i) { putchar (tab ? tab : ' '); prfield (i, line1); } for (i = join_field_1 + 1; i < line1->nfields; ++i) { putchar (tab ? tab : ' '); prfield (i, line1); } for (i = 0; i < join_field_2 && i < line2->nfields; ++i) { putchar (tab ? tab : ' '); prfield (i, line2); } for (i = join_field_2 + 1; i < line2->nfields; ++i) { putchar (tab ? tab : ' '); prfield (i, line2); } putchar ('\n'); } } /* Print the join of the files in FP1 and FP2. */ static void join (fp1, fp2) FILE *fp1; FILE *fp2; { struct seq seq1, seq2; struct line line; int diff, i, j, eof1, eof2; /* Read the first line of each file. */ initseq (&seq1); getseq (fp1, &seq1); initseq (&seq2); getseq (fp2, &seq2); while (seq1.count && seq2.count) { diff = keycmp (&seq1.lines[0], &seq2.lines[0]); if (diff < 0) { if (print_unpairables_1) prjoin (&seq1.lines[0], &uni_blank); freeline (&seq1.lines[0]); seq1.count = 0; getseq (fp1, &seq1); continue; } if (diff > 0) { if (print_unpairables_2) prjoin (&uni_blank, &seq2.lines[0]); freeline (&seq2.lines[0]); seq2.count = 0; getseq (fp2, &seq2); continue; } /* Keep reading lines from file1 as long as they continue to match the current line from file2. */ eof1 = 0; do if (!getseq (fp1, &seq1)) { eof1 = 1; ++seq1.count; break; } while (!keycmp (&seq1.lines[seq1.count - 1], &seq2.lines[0])); /* Keep reading lines from file2 as long as they continue to match the current line from file1. */ eof2 = 0; do if (!getseq (fp2, &seq2)) { eof2 = 1; ++seq2.count; break; } while (!keycmp (&seq1.lines[0], &seq2.lines[seq2.count - 1])); if (print_pairables) { for (i = 0; i < seq1.count - 1; ++i) for (j = 0; j < seq2.count - 1; ++j) prjoin (&seq1.lines[i], &seq2.lines[j]); } for (i = 0; i < seq1.count - 1; ++i) freeline (&seq1.lines[i]); if (!eof1) { seq1.lines[0] = seq1.lines[seq1.count - 1]; seq1.count = 1; } else seq1.count = 0; for (i = 0; i < seq2.count - 1; ++i) freeline (&seq2.lines[i]); if (!eof2) { seq2.lines[0] = seq2.lines[seq2.count - 1]; seq2.count = 1; } else seq2.count = 0; } if (print_unpairables_1 && seq1.count) { prjoin (&seq1.lines[0], &uni_blank); freeline (&seq1.lines[0]); while (get_line (fp1, &line)) { prjoin (&line, &uni_blank); freeline (&line); } } if (print_unpairables_2 && seq2.count) { prjoin (&uni_blank, &seq2.lines[0]); freeline (&seq2.lines[0]); while (get_line (fp2, &line)) { prjoin (&uni_blank, &line); freeline (&line); } } delseq (&seq1); delseq (&seq2); } /* Add a field spec for field FIELD of file FILE to `outlist' and return 1, unless either argument is invalid; then just return 0. */ static int add_field (file, field) int file; int field; { struct outlist *o; if (file < 1 || file > 2 || field < 1) return 0; o = (struct outlist *) xmalloc (sizeof (struct outlist)); o->file = file; o->field = field; o->next = NULL; /* Add to the end of the list so the fields are in the right order. */ if (outlist == NULL) outlist = o; else outlist_end->next = o; outlist_end = o; return 1; } /* Add the comma or blank separated field spec(s) in STR to `outlist'. Return the number of fields added. */ static int add_field_list (str) char *str; { int added = 0; int file = -1, field = -1; int dot_found = 0; for (; *str; str++) { if (*str == ',' || ISBLANK (*str)) { added += add_field (file, field); uni_blank.nfields = max (uni_blank.nfields, field); file = field = -1; dot_found = 0; } else if (*str == '.') dot_found = 1; else if (ISDIGIT (*str)) { if (!dot_found) { if (file == -1) file = 0; file = file * 10 + *str - '0'; } else { if (field == -1) field = 0; field = field * 10 + *str - '0'; } } else return 0; } uni_blank.nfields = max (uni_blank.nfields, field); added += add_field (file, field); return added; } /* Create a blank line with COUNT fields separated by tabs. */ void make_blank (blank, count) struct line *blank; int count; { int i; blank->nfields = count; blank->beg = xmalloc (blank->nfields + 1); blank->fields = (struct field *) xmalloc (sizeof (struct field) * count); for (i = 0; i < blank->nfields; i++) { blank->beg[i] = '\t'; blank->fields[i].beg = &blank->beg[i]; blank->fields[i].len = 0; } blank->beg[i] = '\0'; blank->lim = &blank->beg[i]; } void main (argc, argv) int argc; char *argv[]; { char *names[2]; FILE *fp1, *fp2; int optc, prev_optc = 0, nfiles, val; program_name = argv[0]; /* Initialize this before parsing options. In parsing options, it may be increased. */ uni_blank.nfields = 1; parse_long_options (argc, argv, "join", version_string, usage); nfiles = 0; print_pairables = 1; while ((optc = getopt_long_only (argc, argv, "-a:e:1:2:o:t:v:", longopts, (int *) 0)) != EOF) { switch (optc) { case 0: break; case 'a': val = atoi (optarg); if (val == 1) print_unpairables_1 = 1; else if (val == 2) print_unpairables_2 = 1; else error (2, 0, "invalid file number for `-a'"); break; case 'e': empty_filler = optarg; break; case '1': val = atoi (optarg); if (val <= 0) error (2, 0, "invalid field number for `-1'"); join_field_1 = val - 1; break; case '2': val = atoi (optarg); if (val <= 0) error (2, 0, "invalid field number for `-2'"); join_field_2 = val - 1; break; case 'j': val = atoi (optarg); if (val <= 0) error (2, 0, "invalid field number for `-j'"); join_field_1 = join_field_2 = val - 1; break; case 'o': if (add_field_list (optarg) == 0) error (2, 0, "invalid field list for `-o'"); break; case 't': tab = *optarg; break; case 'v': val = atoi (optarg); if (val == 1) print_unpairables_1 = 1; else if (val == 2) print_unpairables_2 = 1; else error (2, 0, "invalid file number for `-v'"); print_pairables = 0; break; case 1: /* Non-option argument. */ if (prev_optc == 'o') { /* Might be continuation of args to -o. */ if (add_field_list (optarg) > 0) continue; /* Don't change `prev_optc'. */ } if (nfiles > 1) usage (1); names[nfiles++] = optarg; break; case '?': usage (1); } prev_optc = optc; } /* Now that we've seen the options, we can construct the blank line structure. */ make_blank (&uni_blank, uni_blank.nfields); if (nfiles != 2) usage (1); fp1 = strcmp (names[0], "-") ? fopen (names[0], "r") : stdin; if (!fp1) error (1, errno, "%s", names[0]); fp2 = strcmp (names[1], "-") ? fopen (names[1], "r") : stdin; if (!fp2) error (1, errno, "%s", names[1]); if (fp1 == fp2) error (1, errno, "both files cannot be standard input"); join (fp1, fp2); if ((fp1 == stdin || fp2 == stdin) && fclose (stdin) == EOF) error (1, errno, "-"); if (ferror (stdout) || fclose (stdout) == EOF) error (1, errno, "write error"); exit (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]... FILE1 FILE2\n\ ", program_name); printf ("\ For each pair of input lines with identical join fields, write a line to\n\ standard output. The default join field is the first, delimited\n\ by whitespace. When FILE1 or FILE2 (not both) is -, read standard input.\n\ \n\ -a SIDE print unpairable lines coming from file SIDE\n\ -e EMPTY replace missing input fields with EMPTY\n\ -j FIELD join on this FIELD for both files\n\ -[j]SIDE FIELD join on this FIELD for file SIDE\n\ -o FORMAT obey FORMAT while constructing output line\n\ -t CHAR use CHAR as input and output field separator\n\ -v SIDE like -a SIDE, but suppress joined output lines\n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ SIDE is 1 for FILE1 or 2 for FILE2. Unless -t CHAR is given, leading blanks\n\ separate fields and are ignored, else fields are separated by CHAR.\n\ Any FIELD is a field number counted from 1. FORMAT is one or more\n\ comma or blank separated specifications, each being `SIDE.FIELD'.\n\ Default FORMAT outputs the join field, the remaining fields from\n\ FILE1, the remaining fields from FILE2, all separated by CHAR.\n\ "); } exit (status); } textutils-1.12/src/md5sum.c100644 74504 13 51600 5771033345 14756 0ustar meyeringuser/* Compute MD5 checksum of files or strings according to the definition of MD5 in RFC 1321 from April 1992. Copyright (C) 1995 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. */ /* If you want to use this code in your own program as a library just define the preprocessor macro `USE_AS_LIBRARY'. cc -DUSE_AS_LIBRARY -c md5sum.c */ /* Written by Ulrich Drepper . */ #ifdef HAVE_CONFIG_H # include #endif #include #include #include #if HAVE_LIMITS_H || _LIBC # include #endif #include "system.h" #include "error.h" #include "version.h" #ifdef WORDS_BIGENDIAN # define SWAP(n) \ (((n) << 24) | (((n) & 0xff00) << 8) | (((n) >> 8) & 0xff00) | ((n) >> 24)) #else # define SWAP(n) (n) #endif /* For performance reasons we use low-level I/O whenever possible. */ #if UNIX || __UNIX__ || unix || __unix__ || _POSIX_VERSION # define FILETYPE int # define STDINFILE STDIN_FILENO # define OPEN open # define OPENOPTS O_RDONLY # define ILLFILEVAL -1 # define READ(f, b, n) read ((f), (b), (n)) # define CLOSE(f) close (f) #else # ifdef MSDOS # define TEXT1TO1 "rb" # define TEXTCNVT "r" # else # if defined VMS # define TEXT1TO1 "rb", "ctx=stm" # define TEXTCNVT "r", "ctx=stm" # endif # endif # define FILETYPE FILE * # define STDINFILE stdin # define OPEN fopen # define OPENOPTS (binary != 0 ? TEXT1TO1 : TEXTCNVT) # define ILLFILEVAL NULL # define READ(f, b, n) fread ((b), 1, (n), (f)) # define CLOSE(f) fclose (f) #endif #undef __P #if defined __STDC__ && __STDC__ # define __P(args) args #else # define __P(args) () #endif #ifdef __GNUC__ # define INLINE __inline #else # define INLINE /* empty */ #endif /* The following contortions are an attempt to use the C preprocessor to determine an unsigned integral type that is 32 bits wide. An alternative approach is to use autoconf's AC_CHECK_SIZEOF macro, but doing that would require that the configure script compile and *run* the resulting executable. Locally running cross-compiled executables is usually not possible. */ #if defined __STDC__ && __STDC__ # define UINT_MAX_32_BITS 4294967295U #else # define UINT_MAX_32_BITS 0xFFFFFFFF #endif /* If UINT_MAX isn't defined, assume it's a 32-bit type. This should be valid for all systems GNU cares about because that doesn't include 16-bit systems, and only modern systems (that certainly have ) have 64+-bit integral types. */ #ifndef UINT_MAX # define UINT_MAX UINT_MAX_32_BITS #endif #if UINT_MAX == UINT_MAX_32_BITS typedef unsigned int uint32; #else # if USHRT_MAX == UINT_MAX_32_BITS typedef unsigned short uint32; # else /* The following line is intended to throw an error. Using #error is not portable enough. */ "Cannot determine unsigned 32-bit data type." # endif #endif #define TOLOWER(c) (ISUPPER (c) ? tolower (c) : (c)) /* Hook for i18n. */ #define _(str) str /* Structure to save state of computation between the single steps. */ struct md5_ctx { uint32 A; uint32 B; uint32 C; uint32 D; }; /* The name this program was run with. */ char *program_name; /* This array contains the bytes used to pad the buffer to the next 64-byte boundary. (RFC 1321, 3.1: Step 1) */ static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ... */ }; static const struct option long_options[] = { { "binary", no_argument, 0, 'b' }, { "check", required_argument, 0, 'c' }, { "help", no_argument, 0, 'h' }, { "string", required_argument, 0, 's' }, { "text", no_argument, 0, 't' }, { "verbose", no_argument, 0, 'v' }, { "version", no_argument, 0, 'V' }, { NULL, 0, NULL, 0 } }; char *xmalloc (); /* Prototypes for local functions. */ static void usage __P ((int status)); static INLINE void init __P ((struct md5_ctx *ctx)); static INLINE void *result __P ((const struct md5_ctx *ctx, void *resbuf)); void *md5_file __P ((const char *filename, void *resblock, int binary)); void *md5_buffer __P ((const char *buffer, size_t len, void *resblock)); static void process_buffer __P ((const void *buffer, size_t len, struct md5_ctx *ctx)); #ifndef USE_AS_LIBRARY /* FIXME: but this won't work with filenames containing blanks. */ /* FIXME: This is provisory. Use strtok. */ static int split_3 (s, u, v, w) char *s, **u, **v, **w; { size_t i; char *p[3]; #define ISWHITE(c) ((c) == ' ' || (c) == '\t') i = 0; while (s[i] && ISWHITE (s[i])) ++i; if (s[i]) { p[0] = &s[i]; while (s[i] && !ISWHITE (s[i])) ++i; if (s[i]) s[i++] = '\0'; while (s[i] && ISWHITE (s[i])) ++i; if (s[i]) { p[1] = &s[i]; while (s[i] && !ISWHITE (s[i])) ++i; if (s[i]) s[i++] = '\0'; while (s[i] && ISWHITE (s[i])) ++i; if (s[i]) { p[2] = &s[i]; /* Skip past the third token. */ while (s[i] && !ISWHITE (s[i])) ++i; if (s[i]) s[i++] = '\0'; /* Allow trailing white space. */ while (s[i] && ISWHITE (s[i])) ++i; if (!s[i]) { *u = p[0]; *v = p[1]; *w = p[2]; return 0; } } } } return 1; } /* FIXME: use strcspn. */ static int hex_digits (s) const char *s; { while (*s) { if (!ISXDIGIT (*s)) return 0; ++s; } return 1; } int main (argc, argv) int argc; char *argv[]; { unsigned char md5buffer[16]; const char *check_file = NULL; int binary = 1; int do_help = 0; int do_version = 0; int verbose = 0; int opt; char **string = NULL; char n_strings = 0; size_t i; /* Setting values of global variables. */ program_name = argv[0]; while ((opt = getopt_long (argc, argv, "bc:hs::tvV", long_options, NULL)) != EOF) switch (opt) { case 0: /* long option */ break; case 'b': binary = 1; break; case 'c': check_file = optarg; break; case 'h': do_help = 1; break; case 's': { if (string == NULL) string = (char **) xmalloc ((argc - 1) * sizeof (char *)); if (optarg == NULL) optarg = ""; string[n_strings++] = optarg; } break; case 't': binary = 0; break; case 'v': verbose = 1; break; case 'V': do_version = 1; break; default: usage (1); } if (do_version) { printf ("md5sum - %s\n", version_string); exit (0); } if (do_help) usage (0); if (n_strings > 0 && check_file != NULL) { error (0, 0, _("the --string and --check options are mutually exclusive")); usage (1); } if (n_strings > 0) { if (optind < argc) { error (0, 0, _("no files may be specified when using --string")); usage (1); } for (i = 0; i < n_strings; ++i) { size_t cnt; md5_buffer (string[i], strlen (string[i]), md5buffer); for (cnt = 0; cnt < 16; ++cnt) printf ("%02x", md5buffer[cnt]); printf (" b \"%s\"\n", string[i]); } } else if (check_file == NULL) { if (optind == argc) argv[argc++] = "-"; for (; optind < argc; ++optind) { size_t cnt; md5_file (argv[optind], md5buffer, binary); for (cnt = 0; cnt < 16; ++cnt) printf ("%02x", md5buffer[cnt]); printf (" %c %s\n", binary ? 'b' : 't', argv[optind]); } } else { FILE *cfp; int n_tests = 0; int n_tests_failed = 0; if (optind < argc) { error (0, 0, _("no additional files may be specified when using --check")); usage (1); } if (strcmp (check_file, "-") == 0) cfp = stdin; else { cfp = fopen (check_file, "r"); if (cfp == NULL) error (1, errno, _("check file: %s"), check_file); } do { char line[1024]; char *filename; char *type_flag; char *md5num; int err; /* FIXME: Use getline, not fgets. */ if (fgets (line, 1024, cfp) == NULL) break; /* Remove any trailing newline. */ if (line[strlen (line) - 1] == '\n') line[strlen (line) - 1] = '\0'; /* FIXME: maybe accept the output of --string=STRING. */ err = split_3 (line, &md5num, &type_flag, &filename); if (err || strlen (md5num) != 32 || !hex_digits (md5num) || strlen (type_flag) != 1 || (*type_flag != 'b' && *type_flag != 't')) { if (verbose) error (0, 0, _("invalid line in check file: %s"), line); } else { static const char bin2hex[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; size_t cnt; printf ("%s: ", filename); if (verbose) fflush (stdout); ++n_tests; md5_file (filename, md5buffer, *type_flag == 'b'); /* Compare generated binary number with text representation in check file. Ignore case of hex digits. */ for (cnt = 0; cnt < 16; ++cnt) if (TOLOWER (md5num[2 * cnt]) != bin2hex[md5buffer[cnt] >> 4] || TOLOWER (md5num[2 * cnt + 1]) != (bin2hex[md5buffer[cnt] & 0xf])) break; puts (cnt < 16 ? (++n_tests_failed, _("FAILED")) : _("OK")); } } while (!feof (cfp)); printf (_("%d out of %d tests failed\n"), n_tests_failed, n_tests); } exit (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\ or: %s --check=FILE\n\ or: %s --string=STRING\n\ Mandatory arguments to long options are mandatory for short options too.\n\ \n\ -h, --help display this help and exit\n\ -v, --verbose verbose output level\n\ -V, --version output version information and exit\n\ \n\ -b, --binary read files in binary mode (default)\n\ -t, --text read files in text mode\n\ \n\ -c, --check=FILE check MD5 sums against list in FILE\n\ -s, --string=STRING compute checksum for STRING\n\ \n\ The sums are computed as described in RFC 1321. The file given at the -c\n\ option should be a former output of this program. The default mode is to\n\ produce a list with the checksum informations. A file name - denotes stdin.\n"), program_name, program_name, program_name); exit (status); } #endif /* Initialize structure containing state of computation. (RFC 1321, 3.3: Step 3) */ static INLINE void init (ctx) struct md5_ctx *ctx; { ctx->A = 0x67452301; ctx->B = 0xefcdab89; ctx->C = 0x98badcfe; ctx->D = 0x10325476; } /* Put result from CTX in first 16 bytes following RESBUF. The result must be in little endian byte order. */ static INLINE void * result (ctx, resbuf) const struct md5_ctx *ctx; void *resbuf; { ((uint32 *) resbuf)[0] = SWAP (ctx->A); ((uint32 *) resbuf)[1] = SWAP (ctx->B); ((uint32 *) resbuf)[2] = SWAP (ctx->C); ((uint32 *) resbuf)[3] = SWAP (ctx->D); return resbuf; } /* Read file FILENAME and process it using the MD5 algorithm. When BINARY is non-zero and has a "special" text file format (e.g. MSDOG) conversation takes place while reading. The resulting checksum will be written into the 16 bytes beginning at RESBLOCK. */ /* ARGSUSED */ void * md5_file (filename, resblock, binary) const char *filename; void *resblock; int binary; { /* Important: BLOCKSIZE must be a multiple of 64. */ #define BLOCKSIZE 4096 struct md5_ctx ctx; uint32 len[2] = {0, 0}; char buffer[BLOCKSIZE + 72]; size_t pad, sum; FILETYPE f; /* File name - means stdin. */ if (strcmp (filename, "-") == 0) f = STDINFILE; else { /* OPEN and OPENOPTS are macro. They vary according to the system used. For UN*X systems it is simply open(), but for dumb systems like MSDOG it is fopen. Of course are the reading functions chosen according to the open function. */ f = OPEN (filename, OPENOPTS); if (f == ILLFILEVAL) error (1, errno, _("while opening input file `%s'"), filename); } /* Initialize the computation context. */ init (&ctx); /* Iterate over full file contents. */ while (1) { /* We read the file in blocks of BLOCKSIZE bytes. One call of the computation function processes the whole buffer so that with the next round of the loop another block can be read. */ size_t n; sum = 0; /* Read block. Take care for partial reads. */ do { n = READ (f, buffer, BLOCKSIZE - sum); sum += n; } while (sum < BLOCKSIZE && n != 0); /* RFC 1321 specifies the possible length of the file up to 2^64 bits. Here we only compute the number of bytes. Do a double word increment. */ len[0] += sum; if (len[0] < sum) ++len[1]; /* If end of file is reached, end the loop. */ if (n == 0) break; /* Process buffer with BLOCKSIZE bytes. Note that BLOCKSIZE % 64 == 0 */ process_buffer (buffer, BLOCKSIZE, &ctx); } /* The complete file contents is read. Close it now. */ CLOSE (f); /* We can copy 64 byte because the buffer is always big enough. FILLBUF contains the needed bits. */ memcpy (&buffer[sum], fillbuf, 64); /* Compute amount of padding bytes needed. Alignment is done to (N + PAD) % 64 == 56 There is always at least one byte padded. I.e. even the alignment is correctly aligned 64 padding bytes are added. */ pad = sum & 63; pad = pad >= 56 ? 64 + 56 - pad : 56 - pad; /* Put the 64-bit file length in *bits* at the end of the buffer. */ *(uint32 *) &buffer[sum + pad] = SWAP (len[0] << 3); *(uint32 *) &buffer[sum + pad + 4] = SWAP ((len[1] << 3) | (len[0] >> 29)); /* Process last bytes. */ process_buffer (buffer, sum + pad + 8, &ctx); /* Construct result in desired memory. */ return result (&ctx, resblock); } void * md5_buffer (buffer, len, resblock) const char *buffer; size_t len; void *resblock; { struct md5_ctx ctx; char restbuf[64 + 72]; size_t blocks = len & ~63; size_t pad, rest; /* Initialize the computation context. */ init (&ctx); /* Process whole buffer but last len % 64 bytes. */ process_buffer (buffer, blocks, &ctx); /* REST bytes are not processed yet. */ rest = len - blocks; /* Copy to own buffer. */ memcpy (restbuf, &buffer[blocks], rest); /* Append needed fill bytes at end of buffer. We can copy 64 byte because the buffer is always big enough. */ memcpy (&restbuf[rest], fillbuf, 64); /* PAD bytes are used for padding to correct alignment. Note that always at least one byte is padded. */ pad = rest >= 56 ? 64 + 56 - rest : 56 - rest; /* Put length of buffer in *bits* in last eight bytes. */ *(uint32 *) &restbuf[rest + pad] = SWAP (len << 3); *(uint32 *) &restbuf[rest + pad + 4] = SWAP (len >> 29); /* Process last bytes. */ process_buffer (restbuf, rest + pad + 8, &ctx); /* Put result in desired memory area. */ return result (&ctx, resblock); } /* These are the four functions used in the four steps of the MD5 algorithm and defined in the RFC 1321. The first function is a little bit optimized (as found in Colin Plumbs public domain implementation). */ /* #define FF(b, c, d) ((b & c) | (~b & d)) */ #define FF(b, c, d) (d ^ (b & (c ^ d))) #define FG(b, c, d) FF (d, b, c) #define FH(b, c, d) (b ^ c ^ d) #define FI(b, c, d) (c ^ (b | ~d)) /* Process LEN bytes of BUFFER, accumulating context into CTX. It is assumed that LEN % 64 == 0. */ static void process_buffer (buffer, len, ctx) const void *buffer; size_t len; struct md5_ctx *ctx; { uint32 correct_words[16]; const uint32 *words = buffer; size_t nwords = len / sizeof (uint32); const uint32 *endp = words + nwords; uint32 A = ctx->A; uint32 B = ctx->B; uint32 C = ctx->C; uint32 D = ctx->D; /* Process all bytes in the buffer with 64 bytes in each round of the loop. */ while (words < endp) { uint32 *cwp = correct_words; uint32 A_save = A; uint32 B_save = B; uint32 C_save = C; uint32 D_save = D; /* First round: using the given function, the context and a constant the next context is computed. Because the algorithms processing unit is a 32-bit word and it is determined to work on words in little endian byte order we perhaps have to change the byte order before the computation. To reduce the work for the next steps we store the swapped words in the array CORRECT_WORDS. */ #define OP(a, b, c, d, s, T) \ do \ { \ a += FF (b, c, d) + (*cwp++ = SWAP (*words)) + T; \ ++words; \ CYCLIC (a, s); \ a += b; \ } \ while (0) /* It is unfortunate that C does not provide an operator for cyclic rotation. Hope the C compiler is smart enough. */ #define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s))) /* Before we start, one word to the strange constants. They are defined in RFC 1321 as T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64 */ /* Round 1. */ OP (A, B, C, D, 7, 0xd76aa478); OP (D, A, B, C, 12, 0xe8c7b756); OP (C, D, A, B, 17, 0x242070db); OP (B, C, D, A, 22, 0xc1bdceee); OP (A, B, C, D, 7, 0xf57c0faf); OP (D, A, B, C, 12, 0x4787c62a); OP (C, D, A, B, 17, 0xa8304613); OP (B, C, D, A, 22, 0xfd469501); OP (A, B, C, D, 7, 0x698098d8); OP (D, A, B, C, 12, 0x8b44f7af); OP (C, D, A, B, 17, 0xffff5bb1); OP (B, C, D, A, 22, 0x895cd7be); OP (A, B, C, D, 7, 0x6b901122); OP (D, A, B, C, 12, 0xfd987193); OP (C, D, A, B, 17, 0xa679438e); OP (B, C, D, A, 22, 0x49b40821); /* For the second to fourth round we have the possibly swapped words in CORRECT_WORDS. Redefine the macro to take an additional first argument specifying the function to use. */ #undef OP #define OP(f, a, b, c, d, k, s, T) \ do \ { \ a += f (b, c, d) + correct_words[k] + T; \ CYCLIC (a, s); \ a += b; \ } \ while (0) /* Round 2. */ OP (FG, A, B, C, D, 1, 5, 0xf61e2562); OP (FG, D, A, B, C, 6, 9, 0xc040b340); OP (FG, C, D, A, B, 11, 14, 0x265e5a51); OP (FG, B, C, D, A, 0, 20, 0xe9b6c7aa); OP (FG, A, B, C, D, 5, 5, 0xd62f105d); OP (FG, D, A, B, C, 10, 9, 0x02441453); OP (FG, C, D, A, B, 15, 14, 0xd8a1e681); OP (FG, B, C, D, A, 4, 20, 0xe7d3fbc8); OP (FG, A, B, C, D, 9, 5, 0x21e1cde6); OP (FG, D, A, B, C, 14, 9, 0xc33707d6); OP (FG, C, D, A, B, 3, 14, 0xf4d50d87); OP (FG, B, C, D, A, 8, 20, 0x455a14ed); OP (FG, A, B, C, D, 13, 5, 0xa9e3e905); OP (FG, D, A, B, C, 2, 9, 0xfcefa3f8); OP (FG, C, D, A, B, 7, 14, 0x676f02d9); OP (FG, B, C, D, A, 12, 20, 0x8d2a4c8a); /* Round 3. */ OP (FH, A, B, C, D, 5, 4, 0xfffa3942); OP (FH, D, A, B, C, 8, 11, 0x8771f681); OP (FH, C, D, A, B, 11, 16, 0x6d9d6122); OP (FH, B, C, D, A, 14, 23, 0xfde5380c); OP (FH, A, B, C, D, 1, 4, 0xa4beea44); OP (FH, D, A, B, C, 4, 11, 0x4bdecfa9); OP (FH, C, D, A, B, 7, 16, 0xf6bb4b60); OP (FH, B, C, D, A, 10, 23, 0xbebfbc70); OP (FH, A, B, C, D, 13, 4, 0x289b7ec6); OP (FH, D, A, B, C, 0, 11, 0xeaa127fa); OP (FH, C, D, A, B, 3, 16, 0xd4ef3085); OP (FH, B, C, D, A, 6, 23, 0x04881d05); OP (FH, A, B, C, D, 9, 4, 0xd9d4d039); OP (FH, D, A, B, C, 12, 11, 0xe6db99e5); OP (FH, C, D, A, B, 15, 16, 0x1fa27cf8); OP (FH, B, C, D, A, 2, 23, 0xc4ac5665); /* Round 4. */ OP (FI, A, B, C, D, 0, 6, 0xf4292244); OP (FI, D, A, B, C, 7, 10, 0x432aff97); OP (FI, C, D, A, B, 14, 15, 0xab9423a7); OP (FI, B, C, D, A, 5, 21, 0xfc93a039); OP (FI, A, B, C, D, 12, 6, 0x655b59c3); OP (FI, D, A, B, C, 3, 10, 0x8f0ccc92); OP (FI, C, D, A, B, 10, 15, 0xffeff47d); OP (FI, B, C, D, A, 1, 21, 0x85845dd1); OP (FI, A, B, C, D, 8, 6, 0x6fa87e4f); OP (FI, D, A, B, C, 15, 10, 0xfe2ce6e0); OP (FI, C, D, A, B, 6, 15, 0xa3014314); OP (FI, B, C, D, A, 13, 21, 0x4e0811a1); OP (FI, A, B, C, D, 4, 6, 0xf7537e82); OP (FI, D, A, B, C, 11, 10, 0xbd3af235); OP (FI, C, D, A, B, 2, 15, 0x2ad7d2bb); OP (FI, B, C, D, A, 9, 21, 0xeb86d391); /* Add the starting values of the context. */ A += A_save; B += B_save; C += C_save; D += D_save; } /* Put checksum in context given as argument. */ ctx->A = A; ctx->B = B; ctx->C = C; ctx->D = D; } textutils-1.12/src/nl.c100666 74504 13 34031 5770310606 14155 0ustar meyeringuser/* nl -- number lines of files Copyright (C) 1989, 1992, 1995 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* Written by Scott Bartram (nancy!scott@uunet.uu.net) Revised by David MacKenzie (djm@gnu.ai.mit.edu) */ #include #include #include #include #include #include "linebuffer.h" #include "system.h" #include "version.h" #include "error.h" #ifndef TRUE #define TRUE 1 #define FALSE 0 #endif /* Line-number formats. */ enum number_format { FORMAT_RIGHT_NOLZ, /* Right justified, no leading zeroes. */ FORMAT_RIGHT_LZ, /* Right justified, leading zeroes. */ FORMAT_LEFT /* Left justified, no leading zeroes. */ }; /* Default section delimiter characters. */ #define DEFAULT_SECTION_DELIMITERS "\\:" /* Types of input lines: either one of the section delimiters, or text to output. */ enum section { Header, Body, Footer, Text }; char *xmalloc (); char *xrealloc (); static enum section check_section (); static int build_type_arg (); static int nl_file (); static void usage (); static void process_file (); static void proc_header (); static void proc_body (); static void proc_footer (); static void proc_text (); static void print_lineno (); static void build_print_fmt (); /* The name this program was run with. */ char *program_name; /* Format of body lines (-b). */ static char *body_type = "t"; /* Format of header lines (-h). */ static char *header_type = "n"; /* Format of footer lines (-f). */ static char *footer_type = "n"; /* Format currently being used (body, header, or footer). */ static char *current_type; /* Regex for body lines to number (-bp). */ static struct re_pattern_buffer body_regex; /* Regex for header lines to number (-hp). */ static struct re_pattern_buffer header_regex; /* Regex for footer lines to number (-fp). */ static struct re_pattern_buffer footer_regex; /* Pointer to current regex, if any. */ static struct re_pattern_buffer *current_regex = NULL; /* Separator string to print after line number (-s). */ static char *separator_str = "\t"; /* Input section delimiter string (-d). */ static char *section_del = DEFAULT_SECTION_DELIMITERS; /* Header delimiter string. */ static char *header_del = NULL; /* Header section delimiter length. */ static int header_del_len; /* Body delimiter string. */ static char *body_del = NULL; /* Body section delimiter length. */ static int body_del_len; /* Footer delimiter string. */ static char *footer_del = NULL; /* Footer section delimiter length. */ static int footer_del_len; /* Input buffer. */ static struct linebuffer line_buf; /* printf format string for line number. */ static char *print_fmt; /* printf format string for unnumbered lines. */ static char *print_no_line_fmt = NULL; /* Starting line number on each page (-v). */ static int page_start = 1; /* Line number increment (-i). */ static int page_incr = 1; /* If TRUE, reset line number at start of each page (-p). */ static int reset_numbers = TRUE; /* Number of blank lines to consider to be one line for numbering (-l). */ static int blank_join = 1; /* Width of line numbers (-w). */ static int lineno_width = 6; /* Line number format (-n). */ static enum number_format lineno_format = FORMAT_RIGHT_NOLZ; /* Current print line number. */ static int line_no; /* Nonzero if we have ever read standard input. */ static int have_read_stdin; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output then exit. */ static int show_version; static struct option const longopts[] = { {"header-numbering", required_argument, NULL, 'h'}, {"body-numbering", required_argument, NULL, 'b'}, {"footer-numbering", required_argument, NULL, 'f'}, {"first-page", required_argument, NULL, 'v'}, {"page-increment", required_argument, NULL, 'i'}, {"no-renumber", no_argument, NULL, 'p'}, {"join-blank-lines", required_argument, NULL, 'l'}, {"number-separator", required_argument, NULL, 's'}, {"number-width", required_argument, NULL, 'w'}, {"number-format", required_argument, NULL, 'n'}, {"section-delimiter", required_argument, NULL, 'd'}, {"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 c, exit_status = 0; program_name = argv[0]; have_read_stdin = 0; while ((c = getopt_long (argc, argv, "h:b:f:v:i:pl:s:w:n:d:", longopts, (int *) 0)) != EOF) { switch (c) { case 0: break; case 'h': if (build_type_arg (&header_type, &header_regex) != TRUE) usage (2); break; case 'b': if (build_type_arg (&body_type, &body_regex) != TRUE) usage (2); break; case 'f': if (build_type_arg (&footer_type, &footer_regex) != TRUE) usage (2); break; case 'v': page_start = atoi (optarg); break; case 'i': page_incr = atoi (optarg); if (page_incr < 1) page_incr = 1; break; case 'p': reset_numbers = FALSE; break; case 'l': blank_join = atoi (optarg); break; case 's': separator_str = optarg; break; case 'w': lineno_width = atoi (optarg); if (lineno_width < 1) lineno_width = 1; break; case 'n': switch (*optarg) { case 'l': if (optarg[1] == 'n') lineno_format = FORMAT_LEFT; else usage (2); break; case 'r': switch (optarg[1]) { case 'n': lineno_format = FORMAT_RIGHT_NOLZ; break; case 'z': lineno_format = FORMAT_RIGHT_LZ; break; default: usage (2); break; } break; default: usage (2); break; } break; case 'd': section_del = optarg; break; default: usage (2); break; } } if (show_version) { printf ("nl - %s\n", version_string); exit (0); } if (show_help) usage (0); /* Initialize the section delimiters. */ c = strlen (section_del); header_del_len = c * 3; header_del = xmalloc (header_del_len + 1); strcat (strcat (strcpy (header_del, section_del), section_del), section_del); body_del_len = c * 2; body_del = xmalloc (body_del_len + 1); strcat (strcpy (body_del, section_del), section_del); footer_del_len = c; footer_del = xmalloc (footer_del_len + 1); strcpy (footer_del, section_del); /* Initialize the input buffer. */ initbuffer (&line_buf); /* Initialize the printf format for unnumbered lines. */ c = strlen (separator_str); print_no_line_fmt = xmalloc (lineno_width + c + 1); memset (print_no_line_fmt, ' ', lineno_width + c); print_no_line_fmt[lineno_width + c] = '\0'; line_no = page_start; current_type = body_type; current_regex = &body_regex; build_print_fmt (); /* Main processing. */ if (optind == argc) exit_status |= nl_file ("-"); else for (; optind < argc; optind++) exit_status |= nl_file (argv[optind]); if (have_read_stdin && fclose (stdin) == EOF) { error (0, errno, "-"); exit_status = 1; } if (ferror (stdout) || fclose (stdout) == EOF) error (1, errno, "write error"); exit (exit_status); } /* Process file FILE to standard output. Return 0 if successful, 1 if not. */ static int nl_file (file) char *file; { FILE *stream; if (!strcmp (file, "-")) { have_read_stdin = 1; stream = stdin; } else { stream = fopen (file, "r"); if (stream == NULL) { error (0, errno, "%s", file); return 1; } } process_file (stream); if (ferror (stream)) { error (0, errno, "%s", file); return 1; } if (!strcmp (file, "-")) clearerr (stream); /* Also clear EOF. */ else if (fclose (stream) == EOF) { error (0, errno, "%s", file); return 1; } return 0; } /* Read and process the file pointed to by FP. */ static void process_file (fp) FILE *fp; { while (readline (&line_buf, fp)) { switch ((int) check_section ()) { case Header: proc_header (); break; case Body: proc_body (); break; case Footer: proc_footer (); break; case Text: proc_text (); break; } } } /* Return the type of line in `line_buf'. */ static enum section check_section () { if (line_buf.length < 2 || memcmp (line_buf.buffer, section_del, 2)) return Text; if (line_buf.length == header_del_len && !memcmp (line_buf.buffer, header_del, header_del_len)) return Header; if (line_buf.length == body_del_len && !memcmp (line_buf.buffer, body_del, body_del_len)) return Body; if (line_buf.length == footer_del_len && !memcmp (line_buf.buffer, footer_del, footer_del_len)) return Footer; return Text; } /* Switch to a header section. */ static void proc_header () { current_type = header_type; current_regex = &header_regex; if (reset_numbers) line_no = page_start; putchar ('\n'); } /* Switch to a body section. */ static void proc_body () { current_type = body_type; current_regex = &body_regex; putchar ('\n'); } /* Switch to a footer section. */ static void proc_footer () { current_type = footer_type; current_regex = &footer_regex; putchar ('\n'); } /* Process a regular text line in `line_buf'. */ static void proc_text () { static int blank_lines = 0; /* Consecutive blank lines so far. */ switch (*current_type) { case 'a': if (blank_join > 1) { if (line_buf.length || ++blank_lines == blank_join) { print_lineno (); blank_lines = 0; } else printf (print_no_line_fmt); } else print_lineno (); break; case 't': if (line_buf.length) print_lineno (); else printf (print_no_line_fmt); break; case 'n': printf (print_no_line_fmt); break; case 'p': if (re_search (current_regex, line_buf.buffer, line_buf.length, 0, line_buf.length, (struct re_registers *) 0) < 0) printf (print_no_line_fmt); else print_lineno (); break; } fwrite (line_buf.buffer, sizeof (char), line_buf.length, stdout); putchar ('\n'); } /* Print and increment the line number. */ static void print_lineno () { printf (print_fmt, line_no); line_no += page_incr; } /* Build the printf format string, based on `lineno_format'. */ static void build_print_fmt () { /* 12 = 10 chars for lineno_width, 1 for %, 1 for \0. */ print_fmt = xmalloc (strlen (separator_str) + 12); switch (lineno_format) { case FORMAT_RIGHT_NOLZ: sprintf (print_fmt, "%%%dd%s", lineno_width, separator_str); break; case FORMAT_RIGHT_LZ: sprintf (print_fmt, "%%0%dd%s", lineno_width, separator_str); break; case FORMAT_LEFT: sprintf (print_fmt, "%%-%dd%s", lineno_width, separator_str); break; } } /* Set the command line flag TYPEP and possibly the regex pointer REGEXP, according to `optarg'. */ static int build_type_arg (typep, regexp) char **typep; struct re_pattern_buffer *regexp; { const char *errmsg; int rval = TRUE; int optlen; switch (*optarg) { case 'a': case 't': case 'n': *typep = optarg; break; case 'p': *typep = optarg++; optlen = strlen (optarg); regexp->allocated = optlen * 2; regexp->buffer = (unsigned char *) xmalloc (regexp->allocated); regexp->translate = NULL; regexp->fastmap = xmalloc (256); regexp->fastmap_accurate = 0; errmsg = re_compile_pattern (optarg, optlen, regexp); if (errmsg) error (1, 0, "%s", errmsg); break; default: rval = FALSE; break; } return rval; } /* Print a usage message and quit. */ 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 ("\ Write each FILE to standard output, with line numbers added.\n\ With no FILE, or when FILE is -, read standard input.\n\ \n\ -b, --body-numbering=STYLE use STYLE for numbering body lines\n\ -d, --section-delimiter=CC use CC for separating logical pages\n\ -f, --footer-numbering=STYLE use STYLE for numbering footer lines\n\ -h, --header-numbering=STYLE use STYLE for numbering header lines\n\ -i, --page-increment=NUMBER line number increment at each line\n\ -l, --join-blank-lines=NUMBER group of NUMBER empty lines counted as one\n\ -n, --number-format=FORMAT insert line numbers according to FORMAT\n\ -p, --no-renumber do not reset line numbers at logical pages\n\ -s, --number-separator=STRING add STRING after (possible) line number\n\ -v, --first-page=NUMBER first line number on each logical page\n\ -w, --number-width=NUMBER use NUMBER columns for line numbers\n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ By default, selects -v1 -i1 -l1 -sTAB -w6 -nrn -hn -bt -fn. CC are\n\ two delimiter characters for separating logical pages, a missing\n\ second character implies :. Type \\\\ for \\. STYLE is one of:\n\ \n\ a number all lines\n\ t number only nonempty lines\n\ n number no lines\n\ pREGEXP number only lines that contain a match for REGEXP\n\ \n\ FORMAT is one of:\n\ \n\ ln left justified, no leading zeros\n\ rn right justified, no leading zeros\n\ rz right justified, leading zeros\n\ \n\ "); } exit (status); } textutils-1.12/src/od.c100666 74504 13 135621 5770310613 14173 0ustar meyeringuser/* od -- dump files in octal and other formats Copyright (C) 1992, 1995 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* Written by Jim Meyering. */ /* AIX requires this to be the first thing in the file. */ #include #ifdef __GNUC__ #define alloca __builtin_alloca #else /* not __GNUC__ */ #if HAVE_ALLOCA_H #include #else /* not HAVE_ALLOCA_H */ #ifdef _AIX #pragma alloca #else /* not _AIX */ char *alloca (); #endif /* not _AIX */ #endif /* not HAVE_ALLOCA_H */ #endif /* not __GNUC__ */ #include #include #include #include #include "system.h" #include "version.h" #include "xstrtoul.h" #include "error.h" #if defined(__GNUC__) || defined(STDC_HEADERS) #include #endif #ifdef HAVE_LONG_DOUBLE typedef long double LONG_DOUBLE; #else typedef double LONG_DOUBLE; #endif #if HAVE_LIMITS_H #include #endif #ifndef SCHAR_MAX #define SCHAR_MAX 127 #endif #ifndef SCHAR_MIN #define SCHAR_MIN (-128) #endif #ifndef SHRT_MAX #define SHRT_MAX 32767 #endif #ifndef SHRT_MIN #define SHRT_MIN (-32768) #endif #ifndef ULONG_MAX #define ULONG_MAX ((unsigned long) ~(unsigned long) 0) #endif #ifndef OFF_T_MAX /* FIXME: is there a way to do this without relying on the `8 bits per byte' assumption? */ #define OFF_T_MAX (~((off_t)1 << (sizeof (off_t) * 8 - 1))) #endif #define STREQ(a,b) (strcmp((a), (b)) == 0) #ifndef MAX #define MAX(a, b) ((a) > (b) ? (a) : (b)) #endif #ifndef MIN #define MIN(a,b) (((a) < (b)) ? (a) : (b)) #endif /* The default number of input bytes per output line. */ #define DEFAULT_BYTES_PER_BLOCK 16 /* The number of decimal digits of precision in a float. */ #ifndef FLT_DIG #define FLT_DIG 7 #endif /* The number of decimal digits of precision in a double. */ #ifndef DBL_DIG #define DBL_DIG 15 #endif /* The number of decimal digits of precision in a long double. */ #ifndef LDBL_DIG #define LDBL_DIG DBL_DIG #endif char *xmalloc (); char *xrealloc (); enum size_spec { NO_SIZE, CHAR, SHORT, INT, LONG, FLOAT_SINGLE, FLOAT_DOUBLE, FLOAT_LONG_DOUBLE }; enum output_format { SIGNED_DECIMAL, UNSIGNED_DECIMAL, OCTAL, HEXADECIMAL, FLOATING_POINT, NAMED_CHARACTER, CHARACTER }; /* Each output format specification (from POSIX `-t spec' or from old-style options) is represented by one of these structures. */ struct tspec { enum output_format fmt; enum size_spec size; void (*print_function) (); char *fmt_string; }; /* The name this program was run with. */ char *program_name; /* Convert the number of 8-bit bytes of a binary representation to the number of characters (digits + sign if the type is signed) required to represent the same quantity in the specified base/type. For example, a 32-bit (4-byte) quantity may require a field width as wide as the following for these types: 11 unsigned octal 11 signed decimal 10 unsigned decimal 8 unsigned hexadecimal */ static const unsigned int bytes_to_oct_digits[] = {0, 3, 6, 8, 11, 14, 16, 19, 22, 25, 27, 30, 32, 35, 38, 41, 43}; static const unsigned int bytes_to_signed_dec_digits[] = {1, 4, 6, 8, 11, 13, 16, 18, 20, 23, 25, 28, 30, 33, 35, 37, 40}; static const unsigned int bytes_to_unsigned_dec_digits[] = {0, 3, 5, 8, 10, 13, 15, 17, 20, 22, 25, 27, 29, 32, 34, 37, 39}; static const unsigned int bytes_to_hex_digits[] = {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32}; /* Convert enum size_spec to the size of the named type. */ static const int width_bytes[] = { -1, sizeof (char), sizeof (short int), sizeof (int), sizeof (long int), sizeof (float), sizeof (double), sizeof (LONG_DOUBLE) }; /* Names for some non-printing characters. */ static const char *const charname[33] = { "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel", "bs", "ht", "nl", "vt", "ff", "cr", "so", "si", "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb", "can", "em", "sub", "esc", "fs", "gs", "rs", "us", "sp" }; /* A printf control string for printing a file offset. */ static const char *output_address_fmt_string; /* FIXME: make this the number of octal digits in an unsigned long. */ #define MAX_ADDRESS_LENGTH 13 /* Space for a normal address, a space, a pseudo address, parentheses around the pseudo address, and a trailing zero byte. */ static char address_fmt_buffer[2 * MAX_ADDRESS_LENGTH + 4]; static char address_pad[MAX_ADDRESS_LENGTH + 1]; static unsigned long int string_min; static unsigned long int flag_dump_strings; /* Non-zero if we should recognize the pre-POSIX non-option arguments that specified at most one file and optional arguments specifying offset and pseudo-start address. */ static int traditional; /* Non-zero if an old-style `pseudo-address' was specified. */ static long int flag_pseudo_start; /* The difference between the old-style pseudo starting address and the number of bytes to skip. */ static long int pseudo_offset; /* Function to format an address and optionally an additional parenthesized pseudo-address; it returns the formatted string. */ static const char *(*format_address) (/* long unsigned int */); /* The number of input bytes to skip before formatting and writing. */ static off_t n_bytes_to_skip = 0; /* When non-zero, MAX_BYTES_TO_FORMAT is the maximum number of bytes to be read and formatted. Otherwise all input is formatted. */ static int limit_bytes_to_format = 0; /* The maximum number of bytes that will be formatted. This value is used only when LIMIT_BYTES_TO_FORMAT is non-zero. */ static off_t max_bytes_to_format; /* When non-zero and two or more consecutive blocks are equal, format only the first block and output an asterisk alone on the following line to indicate that identical blocks have been elided. */ static int abbreviate_duplicate_blocks = 1; /* An array of specs describing how to format each input block. */ static struct tspec *spec; /* The number of format specs. */ static unsigned int n_specs; /* The allocated length of SPEC. */ static unsigned int n_specs_allocated; /* The number of input bytes formatted per output line. It must be a multiple of the least common multiple of the sizes associated with the specified output types. It should be as large as possible, but no larger than 16 -- unless specified with the -w option. */ static unsigned int bytes_per_block; /* Human-readable representation of *file_list (for error messages). It differs from *file_list only when *file_list is "-". */ static char const *input_filename; /* A NULL-terminated list of the file-arguments from the command line. If no file-arguments were specified, this variable is initialized to { "-", NULL }. */ static char const *const *file_list; /* The input stream associated with the current file. */ static FILE *in_stream; /* If non-zero, at least one of the files we read was standard input. */ static int have_read_stdin; #define LONGEST_INTEGRAL_TYPE long int #define MAX_INTEGRAL_TYPE_SIZE sizeof(LONGEST_INTEGRAL_TYPE) static enum size_spec integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1]; #define MAX_FP_TYPE_SIZE sizeof(LONG_DOUBLE) static enum size_spec fp_type_size[MAX_FP_TYPE_SIZE + 1]; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output then exit. */ static int show_version; static struct option const long_options[] = { /* POSIX options. */ {"skip-bytes", required_argument, NULL, 'j'}, {"address-radix", required_argument, NULL, 'A'}, {"read-bytes", required_argument, NULL, 'N'}, {"format", required_argument, NULL, 't'}, {"output-duplicates", no_argument, NULL, 'v'}, /* non-POSIX options. */ {"strings", optional_argument, NULL, 's'}, {"traditional", no_argument, NULL, 'B'}, {"width", optional_argument, NULL, 'w'}, {"help", no_argument, &show_help, 1}, {"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\ or: %s --traditional [FILE] [[+]OFFSET [[+]LABEL]]\n\ ", program_name, program_name); printf ("\ Write an unambiguous representation, octal bytes by default, of FILE\n\ to standard output. With no FILE, or when FILE is -, read standard input.\n\ \n\ -A, --address-radix=RADIX decide how file offsets are printed\n\ -N, --read-bytes=BYTES limit dump to BYTES input bytes per file\n\ -j, --skip-bytes=BYTES skip BYTES input bytes first on each file\n\ -s, --strings[=BYTES] output strings of at least BYTES graphic chars\n\ -t, --format=TYPE select output format or formats\n\ -v, --output-duplicates do not use * to mark line suppression\n\ -w, --width[=BYTES] output BYTES bytes per output line\n\ --traditional accept arguments in pre-POSIX form\n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ Pre-POSIX format specifications may be intermixed, they accumulate:\n\ -a same as -t a, select named characters\n\ -b same as -t oC, select octal bytes\n\ -c same as -t c, select ASCII characters or backslash escapes\n\ -d same as -t u2, select unsigned decimal shorts\n\ -f same as -t fF, select floats\n\ -h same as -t x2, select hexadecimal shorts\n\ -i same as -t d2, select decimal shorts\n\ -l same as -t d4, select decimal longs\n\ -o same as -t o2, select octal shorts\n\ -x same as -t x2, select hexadecimal shorts\n\ "); printf ("\ \n\ For older syntax (second call format), OFFSET means -j OFFSET. LABEL\n\ is the pseudo-address at first byte printed, incremented when dump is\n\ progressing. For OFFSET and LABEL, a 0x or 0X prefix indicates\n\ hexadecimal, suffixes maybe . for octal and b multiply by 512.\n\ \n\ TYPE is made up of one or more of these specifications:\n\ \n\ a named character\n\ c ASCII character or backslash escape\n\ d[SIZE] signed decimal, SIZE bytes per integer\n\ f[SIZE] floating point, SIZE bytes per integer\n\ o[SIZE] octal, SIZE bytes per integer\n\ u[SIZE] unsigned decimal, SIZE bytes per integer\n\ x[SIZE] hexadecimal, SIZE bytes per integer\n\ \n\ SIZE is a number. For TYPE in doux, SIZE may also be C for\n\ sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\ sizeof(long). If TYPE is f, SIZE may also be F for sizeof(float), D\n\ for sizeof(double) or L for sizeof(long double).\n\ \n\ RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\ BYTES is hexadecimal with 0x or 0X prefix, it is multiplied by 512\n\ with b suffix, by 1024 with k and by 1048576 with m. -s without a\n\ number implies 3. -w without a number implies 32. By default, od\n\ uses -A o -t d2 -w 16.\n\ "); } exit (status); } /* Compute the greatest common denominator of U and V using Euclid's algorithm. */ static unsigned int gcd (u, v) unsigned int u; unsigned int v; { unsigned int t; while (v != 0) { t = u % v; u = v; v = t; } return u; } /* Compute the least common multiple of U and V. */ static unsigned int lcm (u, v) unsigned int u; unsigned int v; { unsigned int t = gcd (u, v); if (t == 0) return 0; return u * v / t; } static void print_s_char (n_bytes, block, fmt_string) long unsigned int n_bytes; const char *block; const char *fmt_string; { int i; for (i = n_bytes; i > 0; i--) { int tmp = (unsigned) *(const unsigned char *) block; if (tmp > SCHAR_MAX) tmp -= SCHAR_MAX - SCHAR_MIN + 1; assert (tmp <= SCHAR_MAX); printf (fmt_string, tmp, (i == 1 ? '\n' : ' ')); block += sizeof (unsigned char); } } static void print_char (n_bytes, block, fmt_string) long unsigned int n_bytes; const char *block; const char *fmt_string; { int i; for (i = n_bytes; i > 0; i--) { unsigned int tmp = *(const unsigned char *) block; printf (fmt_string, tmp, (i == 1 ? '\n' : ' ')); block += sizeof (unsigned char); } } static void print_s_short (n_bytes, block, fmt_string) long unsigned int n_bytes; const char *block; const char *fmt_string; { int i; for (i = n_bytes / sizeof (unsigned short); i > 0; i--) { int tmp = (unsigned) *(const unsigned short *) block; if (tmp > SHRT_MAX) tmp -= SHRT_MAX - SHRT_MIN + 1; assert (tmp <= SHRT_MAX); printf (fmt_string, tmp, (i == 1 ? '\n' : ' ')); block += sizeof (unsigned short); } } static void print_short (n_bytes, block, fmt_string) long unsigned int n_bytes; const char *block; const char *fmt_string; { int i; for (i = n_bytes / sizeof (unsigned short); i > 0; i--) { unsigned int tmp = *(const unsigned short *) block; printf (fmt_string, tmp, (i == 1 ? '\n' : ' ')); block += sizeof (unsigned short); } } static void print_int (n_bytes, block, fmt_string) long unsigned int n_bytes; const char *block; const char *fmt_string; { int i; for (i = n_bytes / sizeof (unsigned int); i > 0; i--) { unsigned int tmp = *(const unsigned int *) block; printf (fmt_string, tmp, (i == 1 ? '\n' : ' ')); block += sizeof (unsigned int); } } static void print_long (n_bytes, block, fmt_string) long unsigned int n_bytes; const char *block; const char *fmt_string; { int i; for (i = n_bytes / sizeof (unsigned long); i > 0; i--) { unsigned long tmp = *(const unsigned long *) block; printf (fmt_string, tmp, (i == 1 ? '\n' : ' ')); block += sizeof (unsigned long); } } static void print_float (n_bytes, block, fmt_string) long unsigned int n_bytes; const char *block; const char *fmt_string; { int i; for (i = n_bytes / sizeof (float); i > 0; i--) { float tmp = *(const float *) block; printf (fmt_string, tmp, (i == 1 ? '\n' : ' ')); block += sizeof (float); } } static void print_double (n_bytes, block, fmt_string) long unsigned int n_bytes; const char *block; const char *fmt_string; { int i; for (i = n_bytes / sizeof (double); i > 0; i--) { double tmp = *(const double *) block; printf (fmt_string, tmp, (i == 1 ? '\n' : ' ')); block += sizeof (double); } } #ifdef HAVE_LONG_DOUBLE static void print_long_double (n_bytes, block, fmt_string) long unsigned int n_bytes; const char *block; const char *fmt_string; { int i; for (i = n_bytes / sizeof (LONG_DOUBLE); i > 0; i--) { LONG_DOUBLE tmp = *(const LONG_DOUBLE *) block; printf (fmt_string, tmp, (i == 1 ? '\n' : ' ')); block += sizeof (LONG_DOUBLE); } } #endif static void print_named_ascii (n_bytes, block, unused_fmt_string) long unsigned int n_bytes; const char *block; const char *unused_fmt_string; { int i; for (i = n_bytes; i > 0; i--) { unsigned int c = *(const unsigned char *) block; unsigned int masked_c = (0x7f & c); const char *s; char buf[5]; if (masked_c == 127) s = "del"; else if (masked_c <= 040) s = charname[masked_c]; else { sprintf (buf, " %c", masked_c); s = buf; } printf ("%3s%c", s, (i == 1 ? '\n' : ' ')); block += sizeof (unsigned char); } } static void print_ascii (n_bytes, block, unused_fmt_string) long unsigned int n_bytes; const char *block; const char *unused_fmt_string; { int i; for (i = n_bytes; i > 0; i--) { unsigned int c = *(const unsigned char *) block; const char *s; char buf[5]; switch (c) { case '\0': s = " \\0"; break; case '\007': s = " \\a"; break; case '\b': s = " \\b"; break; case '\f': s = " \\f"; break; case '\n': s = " \\n"; break; case '\r': s = " \\r"; break; case '\t': s = " \\t"; break; case '\v': s = " \\v"; break; default: sprintf (buf, (ISPRINT (c) ? " %c" : "%03o"), c); s = (const char *) buf; } printf ("%3s%c", s, (i == 1 ? '\n' : ' ')); block += sizeof (unsigned char); } } /* Convert a null-terminated (possibly zero-length) string S to an unsigned long integer value. If S points to a non-digit set *P to S, *VAL to 0, and return 0. Otherwise, accumulate the integer value of the string of digits. If the string of digits represents a value larger than ULONG_MAX, don't modify *VAL or *P and return non-zero. Otherwise, advance *P to the first non-digit after S, set *VAL to the result of the conversion and return zero. */ static int simple_strtoul (s, p, val) const char *s; const char **p; long unsigned int *val; { unsigned long int sum; sum = 0; while (ISDIGIT (*s)) { unsigned int c = *s++ - '0'; if (sum > (ULONG_MAX - c) / 10) return 1; sum = sum * 10 + c; } *p = s; *val = sum; return 0; } /* If S points to a single valid POSIX-style od format string, put a description of that format in *TSPEC, make *NEXT point at the character following the just-decoded format (if *NEXT is non-NULL), and return zero. If S is not valid, don't modify *NEXT or *TSPEC and return non-zero. For example, if S were "d4afL" *NEXT would be set to "afL" and *TSPEC would be { fmt = SIGNED_DECIMAL; size = INT or LONG; (whichever integral_type_size[4] resolves to) print_function = print_int; (assuming size == INT) fmt_string = "%011d%c"; } */ static int decode_one_format (s, next, tspec) const char *s; const char **next; struct tspec *tspec; { enum size_spec size_spec; unsigned long int size; enum output_format fmt; const char *pre_fmt_string; char *fmt_string; void (*print_function) (); const char *p; unsigned int c; assert (tspec != NULL); switch (*s) { case 'd': case 'o': case 'u': case 'x': c = *s; ++s; switch (*s) { case 'C': ++s; size = sizeof (char); break; case 'S': ++s; size = sizeof (short); break; case 'I': ++s; size = sizeof (int); break; case 'L': ++s; size = sizeof (long int); break; default: if (simple_strtoul (s, &p, &size) != 0) return 1; if (p == s) size = sizeof (int); else { if (size > MAX_INTEGRAL_TYPE_SIZE || integral_type_size[size] == NO_SIZE) return 1; s = p; } break; } #define FMT_BYTES_ALLOCATED 9 fmt_string = xmalloc (FMT_BYTES_ALLOCATED); size_spec = integral_type_size[size]; switch (c) { case 'd': fmt = SIGNED_DECIMAL; sprintf (fmt_string, "%%%u%sd%%c", bytes_to_signed_dec_digits[size], (size_spec == LONG ? "l" : "")); break; case 'o': fmt = OCTAL; sprintf (fmt_string, "%%0%u%so%%c", bytes_to_oct_digits[size], (size_spec == LONG ? "l" : "")); break; case 'u': fmt = UNSIGNED_DECIMAL; sprintf (fmt_string, "%%%u%su%%c", bytes_to_unsigned_dec_digits[size], (size_spec == LONG ? "l" : "")); break; case 'x': fmt = HEXADECIMAL; sprintf (fmt_string, "%%0%u%sx%%c", bytes_to_hex_digits[size], (size_spec == LONG ? "l" : "")); break; default: abort (); } assert (strlen (fmt_string) < FMT_BYTES_ALLOCATED); switch (size_spec) { case CHAR: print_function = (fmt == SIGNED_DECIMAL ? print_s_char : print_char); break; case SHORT: print_function = (fmt == SIGNED_DECIMAL ? print_s_short : print_short);; break; case INT: print_function = print_int; break; case LONG: print_function = print_long; break; default: abort (); } break; case 'f': fmt = FLOATING_POINT; ++s; switch (*s) { case 'F': ++s; size = sizeof (float); break; case 'D': ++s; size = sizeof (double); break; case 'L': ++s; size = sizeof (LONG_DOUBLE); break; default: if (simple_strtoul (s, &p, &size) != 0) return 1; if (p == s) size = sizeof (double); else { if (size > MAX_FP_TYPE_SIZE || fp_type_size[size] == NO_SIZE) return 1; s = p; } break; } size_spec = fp_type_size[size]; switch (size_spec) { case FLOAT_SINGLE: print_function = print_float; /* Don't use %#e; not all systems support it. */ pre_fmt_string = "%%%d.%de%%c"; fmt_string = xmalloc (strlen (pre_fmt_string)); sprintf (fmt_string, pre_fmt_string, FLT_DIG + 8, FLT_DIG); break; case FLOAT_DOUBLE: print_function = print_double; pre_fmt_string = "%%%d.%de%%c"; fmt_string = xmalloc (strlen (pre_fmt_string)); sprintf (fmt_string, pre_fmt_string, DBL_DIG + 8, DBL_DIG); break; #ifdef HAVE_LONG_DOUBLE case FLOAT_LONG_DOUBLE: print_function = print_long_double; pre_fmt_string = "%%%d.%dle%%c"; fmt_string = xmalloc (strlen (pre_fmt_string)); sprintf (fmt_string, pre_fmt_string, LDBL_DIG + 8, LDBL_DIG); break; #endif default: abort (); } break; case 'a': ++s; fmt = NAMED_CHARACTER; size_spec = CHAR; fmt_string = NULL; print_function = print_named_ascii; break; case 'c': ++s; fmt = CHARACTER; size_spec = CHAR; fmt_string = NULL; print_function = print_ascii; break; default: return 1; } tspec->size = size_spec; tspec->fmt = fmt; tspec->print_function = print_function; tspec->fmt_string = fmt_string; if (next != NULL) *next = s; return 0; } /* Decode the POSIX-style od format string S. Append the decoded representation to the global array SPEC, reallocating SPEC if necessary. Return zero if S is valid, non-zero otherwise. */ static int decode_format_string (s) const char *s; { assert (s != NULL); while (*s != '\0') { struct tspec tspec; const char *next; if (decode_one_format (s, &next, &tspec)) return 1; assert (s != next); s = next; if (n_specs >= n_specs_allocated) { n_specs_allocated = 1 + (3 * n_specs_allocated) / 2; spec = (struct tspec *) xrealloc (spec, (n_specs_allocated * sizeof (struct tspec))); } memcpy ((char *) &spec[n_specs], (char *) &tspec, sizeof (struct tspec)); ++n_specs; } return 0; } /* Given a list of one or more input filenames FILE_LIST, set the global file pointer IN_STREAM to position N_SKIP in the concatenation of those files. If any file operation fails or if there are fewer than N_SKIP bytes in the combined input, give an error message and return non-zero. When possible, use seek- rather than read operations to advance IN_STREAM. A file name of "-" is interpreted as standard input. */ static int skip (n_skip) off_t n_skip; { int err; err = 0; for ( /* empty */ ; *file_list != NULL; ++file_list) { struct stat file_stats; int j; if (STREQ (*file_list, "-")) { input_filename = "standard input"; in_stream = stdin; have_read_stdin = 1; } else { input_filename = *file_list; in_stream = fopen (input_filename, "r"); if (in_stream == NULL) { error (0, errno, "%s", input_filename); err = 1; continue; } } if (n_skip == 0) break; /* First try using fseek. For large offsets, this extra work is worthwhile. If the offset is below some threshold it may be more efficient to move the pointer by reading. There are two issues when trying to use fseek: - the file must be seekable. - before seeking to the specified position, make sure that the new position is in the current file. Try to do that by getting file's size using fstat(). But that will work only for regular files and dirs. */ if (fstat (fileno (in_stream), &file_stats)) { error (0, errno, "%s", input_filename); err = 1; continue; } /* The st_size field is valid only for regular files and directories. FIXME: is the preceding true? If the number of bytes left to skip is at least as large as the size of the current file, we can decrement n_skip and go on to the next file. */ if (S_ISREG (file_stats.st_mode) || S_ISDIR (file_stats.st_mode)) { if (n_skip >= file_stats.st_size) { n_skip -= file_stats.st_size; if (in_stream != stdin && fclose (in_stream) == EOF) { error (0, errno, "%s", input_filename); err = 1; } continue; } else { if (fseek (in_stream, n_skip, SEEK_SET) == 0) { n_skip = 0; break; } } } /* fseek didn't work or wasn't attempted; do it the slow way. */ for (j = n_skip / BUFSIZ; j >= 0; j--) { char buf[BUFSIZ]; size_t n_bytes_to_read = (j > 0 ? BUFSIZ : n_skip % BUFSIZ); size_t n_bytes_read; n_bytes_read = fread (buf, 1, n_bytes_to_read, in_stream); n_skip -= n_bytes_read; if (n_bytes_read != n_bytes_to_read) break; } if (n_skip == 0) break; } if (n_skip != 0) error (2, 0, "cannot skip past end of combined input"); return err; } static const char * format_address_none (address) long unsigned int address; { return ""; } static const char * format_address_std (address) long unsigned int address; { const char *address_string; sprintf (address_fmt_buffer, output_address_fmt_string, address); address_string = address_fmt_buffer; return address_string; } static const char * format_address_label (address) long unsigned int address; { const char *address_string; assert (output_address_fmt_string != NULL); sprintf (address_fmt_buffer, output_address_fmt_string, address, address + pseudo_offset); address_string = address_fmt_buffer; return address_string; } /* Write N_BYTES bytes from CURR_BLOCK to standard output once for each of the N_SPEC format specs. CURRENT_OFFSET is the byte address of CURR_BLOCK in the concatenation of input files, and it is printed (optionally) only before the output line associated with the first format spec. When duplicate blocks are being abbreviated, the output for a sequence of identical input blocks is the output for the first block followed by an asterisk alone on a line. It is valid to compare the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK. That condition may be false only for the last input block -- and then only when it has not been padded to length BYTES_PER_BLOCK. */ static void write_block (current_offset, n_bytes, prev_block, curr_block) long unsigned int current_offset; long unsigned int n_bytes; const char *prev_block; const char *curr_block; { static int first = 1; static int prev_pair_equal = 0; #define EQUAL_BLOCKS(b1, b2) (memcmp ((b1), (b2), bytes_per_block) == 0) if (abbreviate_duplicate_blocks && !first && n_bytes == bytes_per_block && EQUAL_BLOCKS (prev_block, curr_block)) { if (prev_pair_equal) { /* The two preceding blocks were equal, and the current block is the same as the last one, so print nothing. */ } else { printf ("*\n"); prev_pair_equal = 1; } } else { unsigned int i; prev_pair_equal = 0; for (i = 0; i < n_specs; i++) { printf ("%s ", (i == 0 ? format_address (current_offset) : address_pad)); (*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string); } } first = 0; } /* Test whether there have been errors on in_stream, and close it if it is not standard input. Return non-zero if there has been an error on in_stream or stdout; return zero otherwise. This function will report more than one error only if both a read and a write error have occurred. */ static int check_and_close () { int err; err = 0; if (ferror (in_stream)) { error (0, errno, "%s", input_filename); if (in_stream != stdin) fclose (in_stream); err = 1; } else if (in_stream != stdin && fclose (in_stream) == EOF) { error (0, errno, "%s", input_filename); err = 1; } if (ferror (stdout)) { error (0, errno, "standard output"); err = 1; } return err; } /* Read a single byte into *C from the concatenation of the input files named in the global array FILE_LIST. On the first call to this function, the global variable IN_STREAM is expected to be an open stream associated with the input file *FILE_LIST. If IN_STREAM is at end-of-file, close it and update the global variables IN_STREAM, FILE_LIST, and INPUT_FILENAME so they correspond to the next file in the list. Then try to read a byte from the newly opened file. Repeat if necessary until *FILE_LIST is NULL. When EOF is reached for the last file in FILE_LIST, set *C to EOF and return. Subsequent calls do likewise. The return value is non-zero if any errors occured, zero otherwise. */ static int read_char (c) int *c; { int err; if (*file_list == NULL) { *c = EOF; return 0; } err = 0; while (1) { *c = fgetc (in_stream); if (*c != EOF) return err; err |= check_and_close (); do { ++file_list; if (*file_list == NULL) return err; if (STREQ (*file_list, "-")) { input_filename = "standard input"; in_stream = stdin; have_read_stdin = 1; } else { input_filename = *file_list; in_stream = fopen (input_filename, "r"); if (in_stream == NULL) { error (0, errno, "%s", input_filename); err = 1; } } } while (in_stream == NULL); } } /* Read N bytes into BLOCK from the concatenation of the input files named in the global array FILE_LIST. On the first call to this function, the global variable IN_STREAM is expected to be an open stream associated with the input file *FILE_LIST. On subsequent calls, if *FILE_LIST is NULL, don't modify BLOCK and return zero. If all N bytes cannot be read from IN_STREAM, close IN_STREAM and update the global variables IN_STREAM, FILE_LIST, and INPUT_FILENAME. Then try to read the remaining bytes from the newly opened file. Repeat if necessary until *FILE_LIST is NULL. Set *N_BYTES_IN_BUFFER to the number of bytes read. If an error occurs, it will be detected through ferror when the stream is about to be closed. If there is an error, give a message but continue reading as usual and return non-zero. Otherwise return zero. */ static int read_block (n, block, n_bytes_in_buffer) size_t n; char *block; size_t *n_bytes_in_buffer; { int err; assert (n > 0 && n <= bytes_per_block); *n_bytes_in_buffer = 0; if (n == 0) return 0; if (*file_list == NULL) return 0; /* EOF. */ err = 0; while (1) { size_t n_needed; size_t n_read; n_needed = n - *n_bytes_in_buffer; n_read = fread (block + *n_bytes_in_buffer, 1, n_needed, in_stream); *n_bytes_in_buffer += n_read; if (n_read == n_needed) return err; err |= check_and_close (); do { ++file_list; if (*file_list == NULL) return err; if (STREQ (*file_list, "-")) { input_filename = "standard input"; in_stream = stdin; have_read_stdin = 1; } else { input_filename = *file_list; in_stream = fopen (input_filename, "r"); if (in_stream == NULL) { error (0, errno, "%s", input_filename); err = 1; } } } while (in_stream == NULL); } } /* Return the least common multiple of the sizes associated with the format specs. */ static int get_lcm () { unsigned int i; int l_c_m = 1; for (i = 0; i < n_specs; i++) l_c_m = lcm (l_c_m, width_bytes[(int) spec[i].size]); return l_c_m; } /* If S is a valid pre-POSIX offset specification with an optional leading '+' return the offset it denotes. Otherwise, return -1. */ off_t parse_old_offset (s) const char *s; { int radix; off_t offset; enum strtol_error s_err; long unsigned int tmp; if (*s == '\0') return -1; /* Skip over any leading '+'. */ if (s[0] == '+') ++s; /* Determine the radix we'll use to interpret S. If there is a `.', it's decimal, otherwise, if the string begins with `0X'or `0x', it's hexadecimal, else octal. */ if (strchr (s, '.') != NULL) radix = 10; else { if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X')) radix = 16; else radix = 8; } s_err = xstrtoul (s, NULL, radix, &tmp, "Bb"); if (s_err != LONGINT_OK) { STRTOL_FAIL_WARN (s, "old-style offset", s_err); return -1; } offset = tmp; return offset; } /* Read a chunk of size BYTES_PER_BLOCK from the input files, write the formatted block to standard output, and repeat until the specified maximum number of bytes has been read or until all input has been processed. If the last block read is smaller than BYTES_PER_BLOCK and its size is not a multiple of the size associated with a format spec, extend the input block with zero bytes until its length is a multiple of all format spec sizes. Write the final block. Finally, write on a line by itself the offset of the byte after the last byte read. Accumulate return values from calls to read_block and check_and_close, and if any was non-zero, return non-zero. Otherwise, return zero. */ static int dump () { char *block[2]; off_t current_offset; off_t end_offset; int idx; int err; size_t n_bytes_read; #ifdef lint /* Suppress `used before initialized' warning. */ end_offset = 0; #endif block[0] = (char *) alloca (bytes_per_block); block[1] = (char *) alloca (bytes_per_block); current_offset = n_bytes_to_skip; idx = 0; err = 0; if (limit_bytes_to_format) { end_offset = n_bytes_to_skip + max_bytes_to_format; n_bytes_read = 0; while (current_offset < end_offset) { size_t n_needed; n_needed = MIN (end_offset - current_offset, (off_t) bytes_per_block); err |= read_block (n_needed, block[idx], &n_bytes_read); if (n_bytes_read < bytes_per_block) break; assert (n_bytes_read == bytes_per_block); write_block (current_offset, n_bytes_read, block[!idx], block[idx]); current_offset += n_bytes_read; idx = !idx; } } else { while (1) { err |= read_block (bytes_per_block, block[idx], &n_bytes_read); if (n_bytes_read < bytes_per_block) break; assert (n_bytes_read == bytes_per_block); write_block (current_offset, n_bytes_read, block[!idx], block[idx]); current_offset += n_bytes_read; idx = !idx; } } if (n_bytes_read > 0) { int l_c_m; size_t bytes_to_write; l_c_m = get_lcm (); /* Make bytes_to_write the smallest multiple of l_c_m that is at least as large as n_bytes_read. */ bytes_to_write = l_c_m * (int) ((n_bytes_read + l_c_m - 1) / l_c_m); memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read); write_block (current_offset, bytes_to_write, block[!idx], block[idx]); current_offset += n_bytes_read; } if (output_address_fmt_string != NULL) printf ("%s\n", format_address (current_offset)); if (limit_bytes_to_format && current_offset > end_offset) err |= check_and_close (); return err; } /* STRINGS mode. Find each "string constant" in the input. A string constant is a run of at least `string_min' ASCII graphic (or formatting) characters terminated by a null. Based on a function written by Richard Stallman for a pre-POSIX version of od. Return non-zero if an error occurs. Otherwise, return zero. */ static int dump_strings () { size_t bufsize = MAX (100, string_min); char *buf = xmalloc (bufsize); off_t address = n_bytes_to_skip; int err; err = 0; while (1) { unsigned int i; int c; /* See if the next `string_min' chars are all printing chars. */ tryline: if (limit_bytes_to_format && address >= (n_bytes_to_skip + max_bytes_to_format - string_min)) break; for (i = 0; i < string_min; i++) { err |= read_char (&c); address++; if (c < 0) { free (buf); return err; } if (!ISPRINT (c)) /* Found a non-printing. Try again starting with next char. */ goto tryline; buf[i] = c; } /* We found a run of `string_min' printable characters. Now see if it is terminated with a null byte. */ while (!limit_bytes_to_format || address < n_bytes_to_skip + max_bytes_to_format) { if (i == bufsize) { bufsize = 1 + 3 * bufsize / 2; buf = xrealloc (buf, bufsize); } err |= read_char (&c); address++; if (c < 0) { free (buf); return err; } if (c == '\0') break; /* It is; print this string. */ if (!ISPRINT (c)) goto tryline; /* It isn't; give up on this string. */ buf[i++] = c; /* String continues; store it all. */ } /* If we get here, the string is all printable and null-terminated, so print it. It is all in `buf' and `i' is its length. */ buf[i] = 0; if (output_address_fmt_string != NULL) { printf ("%s ", format_address (address - i - 1)); } for (i = 0; (c = buf[i]); i++) { switch (c) { case '\007': fputs ("\\a", stdout); break; case '\b': fputs ("\\b", stdout); break; case '\f': fputs ("\\f", stdout); break; case '\n': fputs ("\\n", stdout); break; case '\r': fputs ("\\r", stdout); break; case '\t': fputs ("\\t", stdout); break; case '\v': fputs ("\\v", stdout); break; default: putc (c, stdout); } } putchar ('\n'); } /* We reach this point only if we search through (max_bytes_to_format - string_min) bytes before reachine EOF. */ free (buf); err |= check_and_close (); return err; } int main (argc, argv) int argc; char **argv; { int c; int n_files; unsigned int i; unsigned int l_c_m; unsigned int address_pad_len; unsigned long int desired_width; int width_specified = 0; int err; /* The old-style `pseudo starting address' to be printed in parentheses after any true address. */ long int pseudo_start; #ifdef lint /* Suppress `used before initialized' warning. */ pseudo_start = 0; #endif program_name = argv[0]; err = 0; for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++) integral_type_size[i] = NO_SIZE; integral_type_size[sizeof (char)] = CHAR; integral_type_size[sizeof (short int)] = SHORT; integral_type_size[sizeof (int)] = INT; integral_type_size[sizeof (long int)] = LONG; for (i = 0; i <= MAX_FP_TYPE_SIZE; i++) fp_type_size[i] = NO_SIZE; fp_type_size[sizeof (float)] = FLOAT_SINGLE; /* The array entry for `double' is filled in after that for LONG_DOUBLE so that if `long double' is the same type or if long double isn't supported FLOAT_LONG_DOUBLE will never be used. */ fp_type_size[sizeof (LONG_DOUBLE)] = FLOAT_LONG_DOUBLE; fp_type_size[sizeof (double)] = FLOAT_DOUBLE; n_specs = 0; n_specs_allocated = 5; spec = (struct tspec *) xmalloc (n_specs_allocated * sizeof (struct tspec)); output_address_fmt_string = "%07o"; format_address = format_address_std; address_pad_len = 7; flag_dump_strings = 0; while ((c = getopt_long (argc, argv, "abcdfhilos::xw::A:j:N:t:v", long_options, (int *) 0)) != EOF) { unsigned long int tmp; enum strtol_error s_err; switch (c) { case 0: break; case 'A': switch (optarg[0]) { case 'd': output_address_fmt_string = "%07d"; format_address = format_address_std; address_pad_len = 7; break; case 'o': output_address_fmt_string = "%07o"; format_address = format_address_std; address_pad_len = 7; break; case 'x': output_address_fmt_string = "%06x"; format_address = format_address_std; address_pad_len = 6; break; case 'n': output_address_fmt_string = NULL; format_address = format_address_none; address_pad_len = 0; break; default: error (2, 0, "invalid output address radix `%c'; it must be one character from [doxn]", optarg[0]); break; } break; case 'j': s_err = xstrtoul (optarg, NULL, 0, &tmp, "bkm"); n_bytes_to_skip = tmp; if (s_err != LONGINT_OK) STRTOL_FATAL_ERROR (optarg, "skip argument", s_err); break; case 'N': limit_bytes_to_format = 1; /* FIXME: if off_t is long long and that's an 8-byte type, use xstrtouq here. */ s_err = xstrtoul (optarg, NULL, 0, &tmp, "bkm"); max_bytes_to_format = tmp; if (s_err != LONGINT_OK) STRTOL_FATAL_ERROR (optarg, "limit argument", s_err); if (tmp > OFF_T_MAX) error (2, 0, "specified number of bytes `%s' is larger than \ the maximum\nrepresentable value of type off_t", optarg); break; case 's': if (optarg == NULL) string_min = 3; else { s_err = xstrtoul (optarg, NULL, 0, &string_min, "bkm"); if (s_err != LONGINT_OK) STRTOL_FATAL_ERROR (optarg, "minimum string length", s_err); } ++flag_dump_strings; break; case 't': if (decode_format_string (optarg)) error (2, 0, "invalid type string `%s'", optarg); break; case 'v': abbreviate_duplicate_blocks = 0; break; case 'B': traditional = 1; break; /* The next several cases map the old, pre-POSIX format specification options to the corresponding POSIX format specs. GNU od accepts any combination of old- and new-style options. Format specification options accumulate. */ #define CASE_OLD_ARG(old_char,new_string) \ case old_char: \ { \ int tmp; \ tmp = decode_format_string (new_string); \ assert (tmp == 0); \ } \ break CASE_OLD_ARG ('a', "a"); CASE_OLD_ARG ('b', "oC"); CASE_OLD_ARG ('c', "c"); CASE_OLD_ARG ('d', "u2"); CASE_OLD_ARG ('f', "fF"); CASE_OLD_ARG ('h', "x2"); CASE_OLD_ARG ('i', "d2"); CASE_OLD_ARG ('l', "d4"); CASE_OLD_ARG ('o', "o2"); CASE_OLD_ARG ('x', "x2"); #undef CASE_OLD_ARG case 'w': width_specified = 1; if (optarg == NULL) { desired_width = 32; } else { s_err = xstrtoul (optarg, NULL, 10, &desired_width, NULL); if (s_err != LONGINT_OK) STRTOL_FATAL_ERROR (optarg, "width specification", s_err); } break; default: usage (1); break; } } if (show_version) { printf ("od - %s\n", version_string); exit (0); } if (show_help) usage (0); if (flag_dump_strings && n_specs > 0) error (2, 0, "no type may be specified when dumping strings"); n_files = argc - optind; /* If the --backward-compatible option is used, there may be from 0 to 3 remaining command line arguments; handle each case separately. od [file] [[+]offset[.][b] [[+]label[.][b]]] The offset and pseudo_start have the same syntax. */ if (traditional) { off_t offset; if (n_files == 1) { if ((offset = parse_old_offset (argv[optind])) >= 0) { n_bytes_to_skip = offset; --n_files; ++argv; } } else if (n_files == 2) { off_t o1, o2; if ((o1 = parse_old_offset (argv[optind])) >= 0 && (o2 = parse_old_offset (argv[optind + 1])) >= 0) { n_bytes_to_skip = o1; flag_pseudo_start = 1; pseudo_start = o2; argv += 2; n_files -= 2; } else if ((o2 = parse_old_offset (argv[optind + 1])) >= 0) { n_bytes_to_skip = o2; --n_files; argv[optind + 1] = argv[optind]; ++argv; } else { error (0, 0, "invalid second operand in compatibility mode `%s'", argv[optind + 1]); usage (1); } } else if (n_files == 3) { off_t o1, o2; if ((o1 = parse_old_offset (argv[optind + 1])) >= 0 && (o2 = parse_old_offset (argv[optind + 2])) >= 0) { n_bytes_to_skip = o1; flag_pseudo_start = 1; pseudo_start = o2; argv[optind + 2] = argv[optind]; argv += 2; n_files -= 2; } else { error (0, 0, "in compatibility mode the last 2 arguments must be offsets"); usage (1); } } else { error (0, 0, "in compatibility mode there may be no more than 3 arguments"); usage (1); } if (flag_pseudo_start) { static char buf[10]; if (output_address_fmt_string == NULL) { output_address_fmt_string = "(%07o)"; format_address = format_address_std; } else { sprintf (buf, "%s (%s)", output_address_fmt_string, output_address_fmt_string); output_address_fmt_string = buf; format_address = format_address_label; } } } assert (address_pad_len <= MAX_ADDRESS_LENGTH); for (i = 0; i < address_pad_len; i++) address_pad[i] = ' '; address_pad[address_pad_len] = '\0'; if (n_specs == 0) { int d_err = decode_one_format ("o2", NULL, &(spec[0])); assert (d_err == 0); n_specs = 1; } if (n_files > 0) file_list = (char const *const *) &argv[optind]; else { /* If no files were listed on the command line, set up the global array FILE_LIST so that it contains the null-terminated list of one name: "-". */ static char const *const default_file_list[] = {"-", NULL}; file_list = default_file_list; } err |= skip (n_bytes_to_skip); if (in_stream == NULL) goto cleanup; pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0); /* Compute output block length. */ l_c_m = get_lcm (); if (width_specified) { if (desired_width != 0 && desired_width % l_c_m == 0) bytes_per_block = desired_width; else { error (0, 0, "warning: invalid width %lu; using %d instead", desired_width, l_c_m); bytes_per_block = l_c_m; } } else { if (l_c_m < DEFAULT_BYTES_PER_BLOCK) bytes_per_block = l_c_m * (int) (DEFAULT_BYTES_PER_BLOCK / l_c_m); else bytes_per_block = l_c_m; } #ifdef DEBUG for (i = 0; i < n_specs; i++) { printf ("%d: fmt=\"%s\" width=%d\n", i, spec[i].fmt_string, width_bytes[spec[i].size]); } #endif err |= (flag_dump_strings ? dump_strings () : dump ()); cleanup:; if (have_read_stdin && fclose (stdin) == EOF) error (2, errno, "standard input"); if (fclose (stdout) == EOF) error (2, errno, "write error"); exit (err); } textutils-1.12/src/paste.c100644 74504 13 31246 5757356237 14700 0ustar meyeringuser/* paste - merge lines of files Copyright (C) 1984 by David M. Ihnat This program is a total rewrite of the Bell Laboratories Unix(Tm) command of the same name, as of System V. It contains no proprietary code, and therefore may be used without violation of any proprietary agreements whatsoever. However, you will notice that the program is copyrighted by me. This is to assure the program does *not* fall into the public domain. Thus, I may specify just what I am now: This program may be freely copied and distributed, provided this notice remains; it may not be sold for profit without express written consent of the author. Please note that I recreated the behavior of the Unix(Tm) 'paste' command as faithfully as possible, with minor exceptions; however, I haven't run a full set of regression tests. Thus, the user of this program accepts full responsibility for any effects or loss; in particular, the author is not responsible for any losses, explicit or incidental, that may be incurred through use of this program. I ask that any bugs (and, if possible, fixes) be reported to me when possible. -David Ihnat (312) 784-4544 ignatz@homebru.chi.il.us The list of valid escape sequences has been expanded over the Unix version, to include \b, \f, \r, and \v. POSIX changes, bug fixes, long-named options, and cleanup by David MacKenzie . Options: --serial -s Paste one file at a time rather than one line from each file. --delimiters=delim-list -d delim-list Consecutively use the characters in DELIM-LIST instead of tab to separate merged lines. When DELIM-LIST is exhausted, start again at its beginning. A FILE of `-' means standard input. If no FILEs are given, standard input is used. */ #include #include #include #include #include "system.h" #include "version.h" #include "error.h" char *xmalloc (); char *xrealloc (); static char *collapse_escapes (); static int paste_parallel (); static int paste_serial (); static void usage (); /* Indicates that no delimiter should be added in the current position. */ #define EMPTY_DELIM '\0' static FILE dummy_closed; /* Element marking a file that has reached EOF and been closed. */ #define CLOSED (&dummy_closed) static FILE dummy_endlist; /* Element marking end of list of open files. */ #define ENDLIST (&dummy_endlist) /* Name this program was run with. */ char *program_name; /* If nonzero, we have read standard input at some point. */ static int have_read_stdin; /* If nonzero, merge subsequent lines of each file rather than corresponding lines from each file in parallel. */ static int serial_merge; /* The delimeters between lines of input files (used cyclically). */ static char *delims; /* A pointer to the character after the end of `delims'. */ static char *delim_end; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output then exit. */ static int show_version; static struct option const longopts[] = { {"serial", no_argument, 0, 's'}, {"delimiters", required_argument, 0, 'd'}, {"help", no_argument, &show_help, 1}, {"version", no_argument, &show_version, 1}, {0, 0, 0, 0} }; void main (argc, argv) int argc; char **argv; { int optc, exit_status; char default_delims[2], zero_delims[3]; program_name = argv[0]; have_read_stdin = 0; serial_merge = 0; delims = default_delims; strcpy (delims, "\t"); strcpy (zero_delims, "\\0"); while ((optc = getopt_long (argc, argv, "d:s", longopts, (int *) 0)) != EOF) { switch (optc) { case 0: break; case 'd': /* Delimiter character(s). */ if (optarg[0] == '\0') optarg = zero_delims; delims = optarg; break; case 's': serial_merge++; break; default: usage (1); } } if (show_version) { printf ("paste - %s\n", version_string); exit (0); } if (show_help) usage (0); if (optind == argc) argv[argc++] = "-"; delim_end = collapse_escapes (delims); if (!serial_merge) exit_status = paste_parallel (argc - optind, &argv[optind]); else exit_status = paste_serial (argc - optind, &argv[optind]); if (have_read_stdin && fclose (stdin) == EOF) error (1, errno, "-"); if (ferror (stdout) || fclose (stdout) == EOF) error (1, errno, "write error"); exit (exit_status); } /* Replace backslash representations of special characters in STRPTR with their actual values. The set of possible backslash characters has been expanded beyond that recognized by the Unix version. Return a pointer to the character after the new end of STRPTR. */ static char * collapse_escapes (strptr) char *strptr; { register char *strout; strout = strptr; /* Start at the same place, anyway. */ while (*strptr) { if (*strptr != '\\') /* Is it an escape character? */ *strout++ = *strptr++; /* No, just transfer it. */ else { switch (*++strptr) { case '0': *strout++ = EMPTY_DELIM; break; case 'b': *strout++ = '\b'; break; case 'f': *strout++ = '\f'; break; case 'n': *strout++ = '\n'; break; case 'r': *strout++ = '\r'; break; case 't': *strout++ = '\t'; break; case 'v': *strout++ = '\v'; break; default: *strout++ = *strptr; break; } strptr++; } } return strout; } /* Perform column paste on the NFILES files named in FNAMPTR. Return 0 if no errors, 1 if one or more files could not be opened or read. */ static int paste_parallel (nfiles, fnamptr) int nfiles; char **fnamptr; { int errors = 0; /* 1 if open or read errors occur. */ /* Number of files for which space is allocated in `delbuf' and `fileptr'. Enlarged as necessary. */ int file_list_size = 12; int chr; /* Input character. */ int line_length; /* Number of chars in line. */ int somedone; /* 0 if all files empty for this line. */ /* If all files are just ready to be closed, or will be on this round, the string of delimiters must be preserved. delbuf[0] through delbuf[file_list_size] store the delimiters for closed files. */ char *delbuf; int delims_saved; /* Number of delims saved in `delbuf'. */ register char *delimptr; /* Cycling pointer into `delims'. */ FILE **fileptr; /* Streams open to the files to process. */ int files_open; /* Number of files still open to process. */ int i; /* Loop index. */ int opened_stdin = 0; /* Nonzero if any fopen got fd 0. */ #ifdef lint /* Suppress `used before initialized' warning. */ chr = 0; #endif delbuf = (char *) xmalloc (file_list_size + 2); fileptr = (FILE **) xmalloc ((file_list_size + 1) * sizeof (FILE *)); /* Attempt to open all files. This could be expanded to an infinite number of files, but at the (considerable) expense of remembering each file and its current offset, then opening/reading/closing. */ for (files_open = 0; files_open < nfiles; ++files_open) { if (files_open == file_list_size - 2) { file_list_size += 12; delbuf = (char *) xrealloc (delbuf, file_list_size + 2); fileptr = (FILE **) xrealloc (fileptr, (file_list_size + 1) * sizeof (FILE *)); } if (!strcmp (fnamptr[files_open], "-")) { have_read_stdin = 1; fileptr[files_open] = stdin; } else { fileptr[files_open] = fopen (fnamptr[files_open], "r"); if (fileptr[files_open] == NULL) error (1, errno, "%s", fnamptr[files_open]); else if (fileno (fileptr[files_open]) == 0) opened_stdin = 1; } } fileptr[files_open] = ENDLIST; if (opened_stdin && have_read_stdin) error (1, 0, "standard input is closed"); /* Read a line from each file and output it to stdout separated by a delimiter, until we go through the loop without successfully reading from any of the files. */ while (files_open) { /* Set up for the next line. */ somedone = 0; delimptr = delims; delims_saved = 0; for (i = 0; fileptr[i] != ENDLIST && files_open; i++) { line_length = 0; /* Clear so we can easily detect EOF. */ if (fileptr[i] != CLOSED) { chr = getc (fileptr[i]); if (chr != EOF && delims_saved) { fwrite (delbuf, sizeof (char), delims_saved, stdout); delims_saved = 0; } while (chr != EOF) { line_length++; if (chr == '\n') break; putc (chr, stdout); chr = getc (fileptr[i]); } } if (line_length == 0) { /* EOF, read error, or closed file. If an EOF or error, close the file and mark it in the list. */ if (fileptr[i] != CLOSED) { if (ferror (fileptr[i])) { error (0, errno, "%s", fnamptr[i]); errors = 1; } if (fileptr[i] == stdin) clearerr (fileptr[i]); /* Also clear EOF. */ else if (fclose (fileptr[i]) == EOF) { error (0, errno, "%s", fnamptr[i]); errors = 1; } fileptr[i] = CLOSED; files_open--; } if (fileptr[i + 1] == ENDLIST) { /* End of this output line. Is this the end of the whole thing? */ if (somedone) { /* No. Some files were not closed for this line. */ if (delims_saved) { fwrite (delbuf, sizeof (char), delims_saved, stdout); delims_saved = 0; } putc ('\n', stdout); } continue; /* Next read of files, or exit. */ } else { /* Closed file; add delimiter to `delbuf'. */ if (*delimptr != EMPTY_DELIM) delbuf[delims_saved++] = *delimptr; if (++delimptr == delim_end) delimptr = delims; } } else { /* Some data read. */ somedone++; /* Except for last file, replace last newline with delim. */ if (fileptr[i + 1] != ENDLIST) { if (chr != '\n') putc (chr, stdout); if (*delimptr != EMPTY_DELIM) putc (*delimptr, stdout); if (++delimptr == delim_end) delimptr = delims; } else putc (chr, stdout); } } } return errors; } /* Perform serial paste on the NFILES files named in FNAMPTR. Return 0 if no errors, 1 if one or more files could not be opened or read. */ static int paste_serial (nfiles, fnamptr) int nfiles; char **fnamptr; { int errors = 0; /* 1 if open or read errors occur. */ register int charnew, charold; /* Current and previous char read. */ register char *delimptr; /* Current delimiter char. */ register FILE *fileptr; /* Open for reading current file. */ for (; nfiles; nfiles--, fnamptr++) { if (!strcmp (*fnamptr, "-")) { have_read_stdin = 1; fileptr = stdin; } else { fileptr = fopen (*fnamptr, "r"); if (fileptr == NULL) { error (0, errno, "%s", *fnamptr); errors = 1; continue; } } delimptr = delims; /* Set up for delimiter string. */ charold = getc (fileptr); if (charold != EOF) { /* `charold' is set up. Hit it! Keep reading characters, stashing them in `charnew'; output `charold', converting to the appropriate delimiter character if needed. After the EOF, output `charold' if it's a newline; otherwise, output it and then a newline. */ while ((charnew = getc (fileptr)) != EOF) { /* Process the old character. */ if (charold == '\n') { if (*delimptr != EMPTY_DELIM) putc (*delimptr, stdout); if (++delimptr == delim_end) delimptr = delims; } else putc (charold, stdout); charold = charnew; } /* Hit EOF. Process that last character. */ putc (charold, stdout); } if (charold != '\n') putc ('\n', stdout); if (ferror (fileptr)) { error (0, errno, "%s", *fnamptr); errors = 1; } if (fileptr == stdin) clearerr (fileptr); /* Also clear EOF. */ else if (fclose (fileptr) == EOF) { error (0, errno, "%s", *fnamptr); errors = 1; } } return errors; } 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 ("\ Write lines consisting of the sequentially corresponding lines from\n\ each FILE, separated by TABs, to standard output.\n\ With no FILE, or when FILE is -, read standard input.\n\ \n\ -d, --delimiters=LIST reuse characters from LIST instead of TABs\n\ -s, --serial paste one file at a time instead of in parallel\n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ "); } exit (status); } textutils-1.12/src/pr.c100666 74504 13 132127 5770310624 14212 0ustar meyeringuser/* pr -- convert text files for printing. Copyright (C) 1988, 1991, 1995 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* Author: Pete TerMaat. */ /* Things to watch: Sys V screws up on ... pr -n -3 -s: /usr/dict/words pr -m -o10 -n /usr/dict/words{,,,} pr -6 -a -n -o5 /usr/dict/words Ideas: Keep a things_to_do list of functions to call when we know we have something to print. Cleaner than current series of checks. Improve the printing of control prefixes. Options: +PAGE Begin output at page PAGE of the output. -COLUMN Produce output that is COLUMN columns wide and print columns down. -a Print columns across rather than down. The input one two three four will be printed as one two three four -b Balance columns on the last page. -c Print unprintable characters as control prefixes. Control-g is printed as ^G. -d Double space the output. -e[c[k]] Expand tabs to spaces on input. Optional argument C is the input tab character. (Default is `\t'.) Optional argument K is the input tab character's width. (Default is 8.) -F -f Use formfeeds instead of newlines to separate pages. -h header Replace the filename in the header with the string HEADER. -i[c[k]] Replace spaces with tabs on output. Optional argument C is the output tab character. (Default is `\t'.) Optional argument K is the output tab character's width. (Default is 8.) -l lines Set the page length to LINES. Default is 66. -m Print files in parallel. -n[c[k]] Precede each column with a line number. (With parallel files, precede each line with a line number.) Optional argument C is the character to print after each number. (Default `\t'.) Optional argument K is the number of digits per line number. (Default 5.) -o offset Offset each line with a margin OFFSET spaces wide. Total page width is the size of this offset plus the width set with `-w'. -r Ignore files that can't be opened. -s[c] Separate each line with a character. Optional argument C is the character to be used. Default is `\t'. -t Do not print headers or footers. -v Print unprintable characters as escape sequences. Control-G becomes \007. -w width Set the page width to WIDTH characters. */ #include #include #include #include #include #include "system.h" #include "version.h" #include "error.h" char *xmalloc (); char *xrealloc (); static int char_to_clump (); static int read_line (); static int print_page (); static int print_stored (); static int open_file (); static int skip_to_page (); static void getoptarg (); static void usage (); static void print_files (); static void init_header (); static void init_store_cols (); static void store_columns (); static void balance (); static void store_char (); static void pad_down (); static void read_rest_of_line (); static void print_char (); static void cleanup (); #ifndef TRUE #define TRUE 1 #define FALSE 0 #endif /* Used with start_position in the struct COLUMN described below. If start_position == ANYWHERE, we aren't truncating columns and can begin printing a column anywhere. Otherwise we must pad to the horizontal position start_position. */ #define ANYWHERE 0 /* Each column has one of these structures allocated for it. If we're only dealing with one file, fp is the same for all columns. The general strategy is to spend time setting up these column structures (storing columns if necessary), after which printing is a matter of flitting from column to column and calling print_func. Parallel files, single files printing across in multiple columns, and single files printing down in multiple columns all fit the same printing loop. print_func Function used to print lines in this column. If we're storing this column it will be print_stored(), Otherwise it will be read_line(). char_func Function used to process characters in this column. If we're storing this column it will be store_char(), otherwise it will be print_char(). current_line Index of the current entry in line_vector, which contains the index of the first character of the current line in buff[]. lines_stored Number of lines in this column which are stored in buff. lines_to_print If we're storing this column, lines_to_print is the number of stored_lines which remain to be printed. Otherwise it is the number of lines we can print without exceeding lines_per_body. start_position The horizontal position we want to be in before we print the first character in this column. numbered True means precede this column with a line number. */ struct COLUMN { FILE *fp; /* Input stream for this column. */ char *name; /* File name. */ enum { OPEN, ON_HOLD, /* Hit a form feed. */ CLOSED } status; /* Status of the file pointer. */ int (*print_func) (); /* Func to print lines in this col. */ void (*char_func) (); /* Func to print/store chars in this col. */ int current_line; /* Index of current place in line_vector. */ int lines_stored; /* Number of lines stored in buff. */ int lines_to_print; /* No. lines stored or space left on page. */ int start_position; /* Horizontal position of first char. */ int numbered; }; typedef struct COLUMN COLUMN; #define NULLCOL (COLUMN *)0 /* The name under which this program was invoked. */ char *program_name; /* All of the columns to print. */ static COLUMN *column_vector; /* When printing a single file in multiple downward columns, we store the leftmost columns contiguously in buff. To print a line from buff, get the index of the first char from line_vector[i], and print up to line_vector[i + 1]. */ static char *buff; /* Index of the position in buff where the next character will be stored. */ static int buff_current; /* The number of characters in buff. Used for allocation of buff and to detect overflow of buff. */ static int buff_allocated; /* Array of indices into buff. Each entry is an index of the first character of a line. This is used when storing lines to facilitate shuffling when we do column balancing on the last page. */ static int *line_vector; /* Array of horizonal positions. For each line in line_vector, end_vector[line] is the horizontal position we are in after printing that line. We keep track of this so that we know how much we need to pad to prepare for the next column. */ static int *end_vector; /* (-m) True means we're printing multiple files in parallel. */ static int parallel_files = FALSE; /* (-[0-9]+) True means we're given an option explicitly specifying number of columns. Used to detect when this option is used with -m. */ static int explicit_columns = FALSE; /* (-t) True means we're printing headers and footers. */ static int extremities = TRUE; /* True means we need to print a header as soon as we know we've got input to print after it. */ static int print_a_header; /* (-h) True means we're using the standard header rather than a customized one specified by the -h flag. */ static int standard_header = TRUE; /* (-f) True means use formfeeds instead of newlines to separate pages. */ static int use_form_feed = FALSE; /* True means we have read the standard input. */ static int have_read_stdin = FALSE; /* True means the -a flag has been given. */ static int print_across_flag = FALSE; /* True means we're printing one file in multiple (>1) downward columns. */ static int storing_columns = TRUE; /* (-b) True means balance columns on the last page as Sys V does. */ static int balance_columns = FALSE; /* (-l) Number of lines on a page, including header and footer lines. */ static int lines_per_page = 66; /* Number of lines in the header and footer can be reset to 0 using the -t flag. */ static int lines_per_header = 5; static int lines_per_body; static int lines_per_footer = 5; /* (-w) Width in characters of the page. Does not include the width of the margin. */ static int chars_per_line = 72; /* Number of characters in a column. Based on the gutter and page widths. */ static int chars_per_column; /* (-e) True means convert tabs to spaces on input. */ static int untabify_input = FALSE; /* (-e) The input tab character. */ static char input_tab_char = '\t'; /* (-e) Tabstops are at chars_per_tab, 2*chars_per_tab, 3*chars_per_tab, ... where the leftmost column is 1. */ static int chars_per_input_tab = 8; /* (-i) True means convert spaces to tabs on output. */ static int tabify_output = FALSE; /* (-i) The output tab character. */ static char output_tab_char = '\t'; /* (-i) The width of the output tab. */ static int chars_per_output_tab = 8; /* Keeps track of pending white space. When we hit a nonspace character after some whitespace, we print whitespace, tabbing if necessary to get to output_position + spaces_not_printed. */ static int spaces_not_printed; /* Number of spaces between columns (though tabs can be used when possible to use up the equivalent amount of space). Not sure if this is worth making a flag for. BSD uses 0, Sys V uses 1. Sys V looks better. */ static int chars_per_gutter = 1; /* (-o) Number of spaces in the left margin (tabs used when possible). */ static int chars_per_margin = 0; /* Position where the next character will fall. Leftmost position is 0 + chars_per_margin. Rightmost position is chars_per_margin + chars_per_line - 1. This is important for converting spaces to tabs on output. */ static int output_position; /* Horizontal position relative to the current file. (output_position depends on where we are on the page; input_position depends on where we are in the file.) Important for converting tabs to spaces on input. */ static int input_position; /* Count number of failed opens so we can exit with non-zero status if there were any. */ static int failed_opens = 0; /* The horizontal position we'll be at after printing a tab character of width c_ from the position h_. */ #define pos_after_tab(c_, h_) h_ - h_ % c_ + c_ /* The number of spaces taken up if we print a tab character with width c_ from position h_. */ #define tab_width(c_, h_) - h_ % c_ + c_ /* (-NNN) Number of columns of text to print. */ static int columns = 1; /* (+NNN) Page number on which to begin printing. */ static int first_page_number = 1; /* Number of files open (not closed, not on hold). */ static int files_ready_to_read = 0; /* Current page number. Displayed in header. */ static int page_number; /* Current line number. Displayed when -n flag is specified. When printing files in parallel (-m flag), line numbering is as follows: 1 foo goo moo 2 hoo too zoo When printing files across (-a flag), ... 1 foo 2 moo 3 goo 4 hoo 3 too 6 zoo Otherwise, line numbering is as follows: 1 foo 3 goo 5 too 2 moo 4 hoo 6 zoo */ static int line_number; /* (-n) True means lines should be preceded by numbers. */ static int numbered_lines = FALSE; /* (-n) Character which follows each line number. */ static char number_separator = '\t'; /* (-n) Width in characters of a line number. */ static int chars_per_number = 5; /* Used when widening the first column to accommodate numbers -- only needed when printing files in parallel. Includes width of both the number and the number_separator. */ static int number_width; /* Buffer sprintf uses to format a line number. */ static char *number_buff; /* (-v) True means unprintable characters are printed as escape sequences. control-g becomes \007. */ static int use_esc_sequence = FALSE; /* (-c) True means unprintable characters are printed as control prefixes. control-g becomes ^G. */ static int use_cntrl_prefix = FALSE; /* (-d) True means output is double spaced. */ static int double_space = FALSE; /* Number of files opened initially in init_files. Should be 1 unless we're printing multiple files in parallel. */ static int total_files = 0; /* (-r) True means don't complain if we can't open a file. */ static int ignore_failed_opens = FALSE; /* (-s) True means we separate columns with a specified character. */ static int use_column_separator = FALSE; /* Character used to separate columns if the the -s flag has been specified. */ static char column_separator = '\t'; /* Number of separator characters waiting to be printed as soon as we know that we have any input remaining to be printed. */ static int separators_not_printed; /* Position we need to pad to, as soon as we know that we have input remaining to be printed. */ static int padding_not_printed; /* True means we should pad the end of the page. Remains false until we know we have a page to print. */ static int pad_vertically; /* (-h) String of characters used in place of the filename in the header. */ static char *custom_header; /* String containing the date, filename or custom header, and "Page ". */ static char *header; static int *clump_buff; /* True means we truncate lines longer than chars_per_column. */ static int truncate_lines = FALSE; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output then 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} }; /* Return the number of columns that have either an open file or stored lines. */ static int cols_ready_to_print () { COLUMN *q; int i; int n; n = 0; for (q = column_vector, i = 0; i < columns; ++q, ++i) if (q->status == OPEN || (storing_columns && q->lines_stored > 0 && q->lines_to_print > 0)) ++n; return n; } void main (argc, argv) int argc; char **argv; { int c; int accum = 0; int n_files; char **file_names; program_name = argv[0]; n_files = 0; file_names = (argc > 1 ? (char **) xmalloc ((argc - 1) * sizeof (char *)) : NULL); while (1) { c = getopt_long (argc, argv, "-0123456789abcde::fFh:i::l:mn::o:rs::tvw:", long_options, (int *) 0); if (c == 1) /* Non-option argument. */ { char *s; s = optarg; if (*s == '+') { ++s; if (!ISDIGIT (*s)) { error (0, 0, "`+' requires a numeric argument"); usage (2); } /* FIXME: use strtol */ first_page_number = atoi (s); } else { file_names[n_files++] = optarg; } } else { if (ISDIGIT (c)) { accum = accum * 10 + c - '0'; continue; } else { if (accum > 0) { columns = accum; explicit_columns = TRUE; accum = 0; } } } if (c == 1) continue; if (c == EOF) break; switch (c) { case 0: /* getopt long option */ break; case 'a': print_across_flag = TRUE; storing_columns = FALSE; break; case 'b': balance_columns = TRUE; break; case 'c': use_cntrl_prefix = TRUE; break; case 'd': double_space = TRUE; break; case 'e': if (optarg) getoptarg (optarg, 'e', &input_tab_char, &chars_per_input_tab); /* Could check tab width > 0. */ untabify_input = TRUE; break; case 'f': case 'F': use_form_feed = TRUE; break; case 'h': custom_header = optarg; standard_header = FALSE; break; case 'i': if (optarg) getoptarg (optarg, 'i', &output_tab_char, &chars_per_output_tab); /* Could check tab width > 0. */ tabify_output = TRUE; break; case 'l': lines_per_page = atoi (optarg); break; case 'm': parallel_files = TRUE; storing_columns = FALSE; break; case 'n': numbered_lines = TRUE; if (optarg) getoptarg (optarg, 'n', &number_separator, &chars_per_number); break; case 'o': chars_per_margin = atoi (optarg); break; case 'r': ignore_failed_opens = TRUE; break; case 's': use_column_separator = TRUE; if (optarg) { char *s; s = optarg; column_separator = *s; if (*++s) { fprintf (stderr, "\ %s: extra characters in the argument to the `-s' option: `%s'\n", program_name, s); usage (2); } } break; case 't': extremities = FALSE; break; case 'v': use_esc_sequence = TRUE; break; case 'w': chars_per_line = atoi (optarg); break; default: usage (2); break; } } if (show_version) { printf ("pr - %s\n", version_string); exit (0); } if (show_help) usage (0); if (parallel_files && explicit_columns) error (1, 0, "Cannot specify number of columns when printing in parallel."); if (parallel_files && print_across_flag) error (1, 0, "Cannot specify both printing across and printing in parallel."); for ( ; optind < argc; optind++) { file_names[n_files++] = argv[optind]; } if (n_files == 0) { /* No file arguments specified; read from standard input. */ print_files (0, (char **) 0); } else { if (parallel_files) print_files (n_files, file_names); else { int i; for (i=0; i 0) exit(1); exit (0); } /* Parse options of the form -scNNN. Example: -nck, where 'n' is the option, c is the optional number separator, and k is the optional width of the field used when printing a number. */ static void getoptarg (arg, switch_char, character, number) char *arg, switch_char, *character; int *number; { if (!ISDIGIT (*arg)) *character = *arg++; if (*arg) { if (ISDIGIT (*arg)) *number = atoi (arg); else { fprintf (stderr, "\ %s: extra characters in the argument to the `-%c' option: `%s'\n", program_name, switch_char, arg); usage (2); } } } /* Set parameters related to formatting. */ static void init_parameters (number_of_files) int number_of_files; { int chars_used_by_number = 0; lines_per_body = lines_per_page - lines_per_header - lines_per_footer; if (lines_per_body <= 0) extremities = FALSE; if (extremities == FALSE) lines_per_body = lines_per_page; if (double_space) lines_per_body = lines_per_body / 2; /* If input is stdin, cannot print parallel files. BSD dumps core on this. */ if (number_of_files == 0) parallel_files = FALSE; if (parallel_files) columns = number_of_files; /* Tabification is assumed for multiple columns. */ if (columns > 1) { if (!use_column_separator) truncate_lines = TRUE; untabify_input = TRUE; tabify_output = TRUE; } else storing_columns = FALSE; if (numbered_lines) { if (number_separator == input_tab_char) { number_width = chars_per_number + tab_width (chars_per_input_tab, (chars_per_margin + chars_per_number)); } else number_width = chars_per_number + 1; /* The number is part of the column width unless we are printing files in parallel. */ if (parallel_files) chars_used_by_number = number_width; } chars_per_column = (chars_per_line - chars_used_by_number - (columns - 1) * chars_per_gutter) / columns; if (chars_per_column < 1) error (1, 0, "page width too narrow"); if (numbered_lines) { if (number_buff != (char *) 0) free (number_buff); number_buff = (char *) xmalloc (2 * chars_per_number * sizeof (char)); } /* Pick the maximum between the tab width and the width of an escape sequence. */ if (clump_buff != (int *) 0) free (clump_buff); clump_buff = (int *) xmalloc ((chars_per_input_tab > 4 ? chars_per_input_tab : 4) * sizeof (int)); } /* Open the necessary files, maintaining a COLUMN structure for each column. With multiple files, each column p has a different p->fp. With single files, each column p has the same p->fp. Return 1 if (number_of_files > 0) and no files can be opened, 0 otherwise. */ static int init_fps (number_of_files, av) int number_of_files; char **av; { int i, files_left; COLUMN *p; FILE *firstfp; char *firstname; total_files = 0; if (column_vector != NULLCOL) free ((char *) column_vector); column_vector = (COLUMN *) xmalloc (columns * sizeof (COLUMN)); if (parallel_files) { files_left = number_of_files; for (p = column_vector; files_left--; ++p, ++av) { if (open_file (*av, p) == 0) { --p; --columns; } } if (columns == 0) return 1; init_header ("", -1); } else { p = column_vector; if (number_of_files > 0) { if (open_file (*av, p) == 0) return 1; init_header (*av, fileno (p->fp)); } else { p->name = "standard input"; p->fp = stdin; have_read_stdin = TRUE; p->status = OPEN; ++total_files; init_header ("", -1); } firstname = p->name; firstfp = p->fp; for (i = columns - 1, ++p; i; --i, ++p) { p->name = firstname; p->fp = firstfp; p->status = OPEN; } } files_ready_to_read = total_files; return 0; } /* Determine print_func and char_func, the functions used by each column for printing and/or storing. Determine the horizontal position desired when we begin printing a column (p->start_position). */ static void init_funcs () { int i, h, h_next; COLUMN *p; h = chars_per_margin; if (use_column_separator) h_next = ANYWHERE; else { /* When numbering lines of parallel files, we enlarge the first column to accomodate the number. Looks better than the Sys V approach. */ if (parallel_files && numbered_lines) h_next = h + chars_per_column + number_width; else h_next = h + chars_per_column; } /* This loop takes care of all but the rightmost column. */ for (p = column_vector, i = 1; i < columns; ++p, ++i) { if (storing_columns) /* One file, multi columns down. */ { p->char_func = store_char; p->print_func = print_stored; } else /* One file, multi columns across; or parallel files. */ { p->char_func = print_char; p->print_func = read_line; } /* Number only the first column when printing files in parallel. */ p->numbered = numbered_lines && (!parallel_files || i == 1); p->start_position = h; /* If we're using separators, all start_positions are ANYWHERE, except the first column's start_position when using a margin. */ if (use_column_separator) { h = ANYWHERE; h_next = ANYWHERE; } else { h = h_next + chars_per_gutter; h_next = h + chars_per_column; } } /* The rightmost column. Doesn't need to be stored unless we intend to balance columns on the last page. */ if (storing_columns && balance_columns) { p->char_func = store_char; p->print_func = print_stored; } else { p->char_func = print_char; p->print_func = read_line; } p->numbered = numbered_lines && (!parallel_files || i == 1); p->start_position = h; } /* Open a file. Return nonzero if successful, zero if failed. */ static int open_file (name, p) char *name; COLUMN *p; { if (!strcmp (name, "-")) { p->name = "standard input"; p->fp = stdin; have_read_stdin = 1; } else { p->name = name; p->fp = fopen (name, "r"); } if (p->fp == NULL) { ++failed_opens; if (!ignore_failed_opens) error (0, errno, "%s", name); return 0; } p->status = OPEN; ++total_files; return 1; } /* Close the file in P. If we aren't dealing with multiple files in parallel, we change the status of all columns in the column list to reflect the close. */ static void close_file (p) COLUMN *p; { COLUMN *q; int i; if (p->status == CLOSED) return; if (ferror (p->fp)) error (1, errno, "%s", p->name); if (p->fp != stdin && fclose (p->fp) == EOF) error (1, errno, "%s", p->name); if (!parallel_files) { for (q = column_vector, i = columns; i; ++q, --i) { q->status = CLOSED; if (q->lines_stored == 0) { q->lines_to_print = 0; } } } else { p->status = CLOSED; p->lines_to_print = 0; } --files_ready_to_read; } /* Put a file on hold until we start a new page, since we've hit a form feed. If we aren't dealing with parallel files, we must change the status of all columns in the column list. */ static void hold_file (p) COLUMN *p; { COLUMN *q; int i; if (!parallel_files) for (q = column_vector, i = columns; i; ++q, --i) q->status = ON_HOLD; else p->status = ON_HOLD; p->lines_to_print = 0; --files_ready_to_read; } /* Undo hold_file -- go through the column list and change any ON_HOLD columns to OPEN. Used at the end of each page. */ static void reset_status () { int i = columns; COLUMN *p; for (p = column_vector; i; --i, ++p) if (p->status == ON_HOLD) { p->status = OPEN; files_ready_to_read++; } } /* Print a single file, or multiple files in parallel. Set up the list of columns, opening the necessary files. Allocate space for storing columns, if necessary. Skip to first_page_number, if user has asked to skip leading pages. Determine which functions are appropriate to store/print lines in each column. Print the file(s). */ static void print_files (number_of_files, av) int number_of_files; char **av; { init_parameters (number_of_files); if (init_fps (number_of_files, av)) return; if (storing_columns) init_store_cols (); if (first_page_number > 1) { if (!skip_to_page (first_page_number)) return; else page_number = first_page_number; } else page_number = 1; init_funcs (); line_number = 1; while (print_page ()) ; } /* Generous estimate of number of characters taken up by "Jun 7 00:08 " and "Page NNNNN". */ #define CHARS_FOR_DATE_AND_PAGE 50 /* Initialize header information. If DESC is non-negative, it is a file descriptor open to FILENAME for reading. Allocate space for a header string, Determine the time, insert file name or user-specified string. It might be nice to have a "blank headers" option, since pr -h "" still prints the date and page number. */ static void init_header (filename, desc) char *filename; int desc; { int chars_per_header; char *f = filename; char *t, *middle; struct stat st; if (filename == 0) f = ""; /* If parallel files or standard input, use current time. */ if (desc < 0 || !strcmp (filename, "-") || fstat (desc, &st)) st.st_mtime = time ((time_t *) 0); t = ctime (&st.st_mtime); t[16] = '\0'; /* Mark end of month and time string. */ t[24] = '\0'; /* Mark end of year string. */ middle = standard_header ? f : custom_header; chars_per_header = strlen (middle) + CHARS_FOR_DATE_AND_PAGE + 1; if (header != (char *) 0) free (header); header = (char *) xmalloc (chars_per_header * sizeof (char)); sprintf (header, "%s %s %s Page", &t[4], &t[20], middle); } /* Set things up for printing a page Scan through the columns ... Determine which are ready to print (i.e., which have lines stored or open files) Set p->lines_to_print appropriately (to p->lines_stored if we're storing, or lines_per_body if we're reading straight from the file) Keep track of this total so we know when to stop printing */ static void init_page () { int j; COLUMN *p; if (storing_columns) { store_columns (); for (j = columns - 1, p = column_vector; j; --j, ++p) { p->lines_to_print = p->lines_stored; } /* Last column. */ if (balance_columns) { p->lines_to_print = p->lines_stored; } /* Since we're not balancing columns, we don't need to store the rightmost column. Read it straight from the file. */ else { if (p->status == OPEN) { p->lines_to_print = lines_per_body; } else p->lines_to_print = 0; } } else for (j = columns, p = column_vector; j; --j, ++p) if (p->status == OPEN) { p->lines_to_print = lines_per_body; } else p->lines_to_print = 0; } /* Print one page. As long as there are lines left on the page and columns ready to print, Scan across the column list if the column has stored lines or the file is open pad to the appropriate spot print the column pad the remainder of the page with \n or \f as requested reset the status of all files -- any files which where on hold because of formfeeds are now put back into the lineup. */ static int print_page () { int j; int lines_left_on_page; COLUMN *p; /* Used as an accumulator (with | operator) of successive values of pad_vertically. The trick is to set pad_vertically to zero before each run through the inner loop, then after that loop, it tells us whether a line was actually printed (whether a newline needs to be output -- or two for double spacing). But those values have to be accumulated (in pv) so we can invoke pad_down properly after the outer loop completes. */ int pv; init_page (); if (cols_ready_to_print () == 0) return FALSE; if (extremities) print_a_header = TRUE; /* Don't pad unless we know a page was printed. */ pad_vertically = FALSE; pv = FALSE; lines_left_on_page = lines_per_body; if (double_space) lines_left_on_page *= 2; while (lines_left_on_page > 0 && cols_ready_to_print () > 0) { output_position = 0; spaces_not_printed = 0; separators_not_printed = 0; pad_vertically = FALSE; for (j = 1, p = column_vector; j <= columns; ++j, ++p) { input_position = 0; if (p->lines_to_print > 0) { padding_not_printed = p->start_position; if (!(p->print_func) (p)) read_rest_of_line (p); pv |= pad_vertically; if (use_column_separator) ++separators_not_printed; --p->lines_to_print; if (p->lines_to_print <= 0) { if (cols_ready_to_print () <= 0) break; } } } if (pad_vertically) { putchar ('\n'); --lines_left_on_page; } if (double_space && pv && extremities) { putchar ('\n'); --lines_left_on_page; } } pad_vertically = pv; if (pad_vertically && extremities) pad_down (lines_left_on_page + lines_per_footer); reset_status (); /* Change ON_HOLD to OPEN. */ return TRUE; /* More pages to go. */ } /* Allocate space for storing columns. This is necessary when printing multiple columns from a single file. Lines are stored consecutively in buff, separated by '\0'. (We can't use a fixed offset since with the '-s' flag lines aren't truncated.) We maintain a list (line_vector) of pointers to the beginnings of lines in buff. We allocate one more than the number of lines because the last entry tells us the index of the last character, which we need to know in order to print the last line in buff. */ static void init_store_cols () { int total_lines = lines_per_body * columns; int chars_if_truncate = total_lines * (chars_per_column + 1); if (line_vector != (int *) 0) free ((int *) line_vector); line_vector = (int *) xmalloc ((total_lines + 1) * sizeof (int *)); if (end_vector != (int *) 0) free ((int *) end_vector); end_vector = (int *) xmalloc (total_lines * sizeof (int *)); if (buff != (char *) 0) free (buff); buff_allocated = use_column_separator ? 2 * chars_if_truncate : chars_if_truncate; /* Tune this. */ buff = (char *) xmalloc (buff_allocated * sizeof (char)); } /* Store all but the rightmost column. (Used when printing a single file in multiple downward columns) For each column set p->current_line to be the index in line_vector of the first line in the column For each line in the column store the line in buff add to line_vector the index of the line's first char buff_start is the index in buff of the first character in the current line. */ static void store_columns () { int i, j; int line = 0; int buff_start; int last_col; /* The rightmost column which will be saved in buff */ COLUMN *p; buff_current = 0; buff_start = 0; if (balance_columns) last_col = columns; else last_col = columns - 1; for (i = 1, p = column_vector; i <= last_col; ++i, ++p) p->lines_stored = 0; for (i = 1, p = column_vector; i <= last_col && files_ready_to_read; ++i, ++p) { p->current_line = line; for (j = lines_per_body; j && files_ready_to_read; --j) if (p->status == OPEN) /* Redundant. Clean up. */ { input_position = 0; if (!read_line (p, i)) read_rest_of_line (p); if (p->status == OPEN || buff_start != buff_current) { ++p->lines_stored; line_vector[line] = buff_start; end_vector[line++] = input_position; buff_start = buff_current; } } } /* Keep track of the location of the last char in buff. */ line_vector[line] = buff_start; if (balance_columns && p->lines_stored != lines_per_body) balance (line); } static void balance (total_stored) int total_stored; { COLUMN *p; int i, lines; int first_line = 0; for (i = 1, p = column_vector; i <= columns; ++i, ++p) { lines = total_stored / columns; if (i <= total_stored % columns) ++lines; p->lines_stored = lines; p->current_line = first_line; first_line += lines; } } /* Store a character in the buffer. */ static void store_char (c) int c; { if (buff_current >= buff_allocated) { /* May be too generous. */ buff_allocated = 2 * buff_allocated; buff = (char *) xrealloc (buff, buff_allocated * sizeof (char)); } buff[buff_current++] = (char) c; } static void number (p) COLUMN *p; { int i; char *s; sprintf (number_buff, "%*d", chars_per_number, line_number++); s = number_buff; for (i = chars_per_number; i > 0; i--) (p->char_func) ((int) *s++); if (number_separator == input_tab_char) { i = number_width - chars_per_number; while (i-- > 0) (p->char_func) ((int) ' '); } else (p->char_func) ((int) number_separator); if (truncate_lines && !parallel_files) input_position += number_width; } /* Print (or store) padding until the current horizontal position is position. */ static void pad_across_to (position) int position; { register int h = output_position; if (tabify_output) spaces_not_printed = position - output_position; else { while (++h <= position) putchar (' '); output_position = position; } } /* Pad to the bottom of the page. If the user has requested a formfeed, use one. Otherwise, use newlines. */ static void pad_down (lines) int lines; { register int i; if (use_form_feed) putchar ('\f'); else for (i = lines; i; --i) putchar ('\n'); } /* Read the rest of the line. Read from the current column's file until an end of line is hit. Used when we've truncated a line and we no longer need to print or store its characters. */ static void read_rest_of_line (p) COLUMN *p; { register int c; FILE *f = p->fp; while ((c = getc (f)) != '\n') { if (c == '\f') { hold_file (p); break; } else if (c == EOF) { close_file (p); break; } } } /* If we're tabifying output, When print_char encounters white space it keeps track of our desired horizontal position and delays printing until this function is called. */ static void print_white_space () { register int h_new; register int h_old = output_position; register int goal = h_old + spaces_not_printed; while (goal - h_old > 1 && (h_new = pos_after_tab (chars_per_output_tab, h_old)) <= goal) { putchar (output_tab_char); h_old = h_new; } while (++h_old <= goal) putchar (' '); output_position = goal; spaces_not_printed = 0; } /* Print column separators. We keep a count until we know that we'll be printing a line, then print_separators() is called. */ static void print_separators () { for (; separators_not_printed > 0; --separators_not_printed) print_char (column_separator); } /* Print (or store, depending on p->char_func) a clump of N characters. */ static void print_clump (p, n, clump) COLUMN *p; int n; int *clump; { while (n--) (p->char_func) (*clump++); } /* Print a character. If we're tabifying, all tabs have been converted to spaces by process_char(). Keep a count of consecutive spaces, and when a nonspace is encountered, call print_white_space() to print the required number of tabs and spaces. */ static void print_char (c) int c; { if (tabify_output) { if (c == ' ') { ++spaces_not_printed; return; } else if (spaces_not_printed > 0) print_white_space (); /* Nonprintables are assumed to have width 0, except '\b'. */ if (!ISPRINT (c)) { if (c == '\b') --output_position; } else ++output_position; } putchar (c); } /* Skip to page PAGE before printing. */ static int skip_to_page (page) int page; { int n, i, j; COLUMN *p; for (n = 1; n < page; ++n) { for (i = 1; i <= lines_per_body; ++i) { for (j = 1, p = column_vector; j <= columns; ++j, ++p) read_rest_of_line (p); } reset_status (); } return files_ready_to_read > 0; } /* Print a header. Formfeeds are assumed to use up two lines at the beginning of the page. */ static void print_header () { if (!use_form_feed) fprintf (stdout, "\n\n"); output_position = 0; pad_across_to (chars_per_margin); print_white_space (); fprintf (stdout, "%s %d\n\n\n", header, page_number++); print_a_header = FALSE; output_position = 0; } /* Print (or store, if p->char_func is store_char()) a line. Read a character to determine whether we have a line or not. (We may hit EOF, \n, or \f) Once we know we have a line, set pad_vertically = TRUE, meaning it's safe to pad down at the end of the page, since we do have a page. print a header if needed. pad across to padding_not_printed if needed. print any separators which need to be printed. print a line number if it needs to be printed. Print the clump which corresponds to the first character. Enter a loop and keep printing until an end of line condition exists, or until we exceed chars_per_column. Return FALSE if we exceed chars_per_column before reading an end of line character, TRUE otherwise. */ static int read_line (p) COLUMN *p; { register int c, chars; int last_input_position; c = getc (p->fp); last_input_position = input_position; switch (c) { case '\f': hold_file (p); return TRUE; case EOF: close_file (p); return TRUE; case '\n': break; default: chars = char_to_clump (c); } if (truncate_lines && input_position > chars_per_column) { input_position = last_input_position; return FALSE; } if (p->char_func != store_char) { pad_vertically = TRUE; if (print_a_header) print_header (); if (padding_not_printed != ANYWHERE) { pad_across_to (padding_not_printed); padding_not_printed = ANYWHERE; } if (use_column_separator) print_separators (); } if (p->numbered) number (p); if (c == '\n') return TRUE; print_clump (p, chars, clump_buff); for (;;) { c = getc (p->fp); switch (c) { case '\n': return TRUE; case '\f': hold_file (p); return TRUE; case EOF: close_file (p); return TRUE; } last_input_position = input_position; chars = char_to_clump (c); if (truncate_lines && input_position > chars_per_column) { input_position = last_input_position; return FALSE; } print_clump (p, chars, clump_buff); } } /* Print a line from buff. If this function has been called, we know we have something to print. Therefore we set pad_vertically to TRUE, print a header if necessary, pad across if necessary, and print separators if necessary. Return TRUE, meaning there is no need to call read_rest_of_line. */ static int print_stored (p) COLUMN *p; { int line = p->current_line++; register char *first = &buff[line_vector[line]]; register char *last = &buff[line_vector[line + 1]]; pad_vertically = TRUE; if (print_a_header) print_header (); if (padding_not_printed != ANYWHERE) { pad_across_to (padding_not_printed); padding_not_printed = ANYWHERE; } if (use_column_separator) print_separators (); while (first != last) print_char (*first++); if (spaces_not_printed == 0) output_position = p->start_position + end_vector[line]; return TRUE; } /* Convert a character to the proper format and return the number of characters in the resulting clump. Increment input_position by the width of the clump. Tabs are converted to clumps of spaces. Nonprintable characters may be converted to clumps of escape sequences or control prefixes. Note: the width of a clump is not necessarily equal to the number of characters in clump_buff. (e.g, the width of '\b' is -1, while the number of characters is 1.) */ static int char_to_clump (c) int c; { register int *s = clump_buff; register int i; char esc_buff[4]; int width; int chars; if (c == input_tab_char) { width = tab_width (chars_per_input_tab, input_position); if (untabify_input) { for (i = width; i; --i) *s++ = ' '; chars = width; } else { *s = c; chars = 1; } } else if (!ISPRINT (c)) { if (use_esc_sequence) { width = 4; chars = 4; *s++ = '\\'; sprintf (esc_buff, "%03o", c); for (i = 0; i <= 2; ++i) *s++ = (int) esc_buff[i]; } else if (use_cntrl_prefix) { if (c < 0200) { width = 2; chars = 2; *s++ = '^'; *s++ = c ^ 0100; } else { width = 4; chars = 4; *s++ = '\\'; sprintf (esc_buff, "%03o", c); for (i = 0; i <= 2; ++i) *s++ = (int) esc_buff[i]; } } else if (c == '\b') { width = -1; chars = 1; *s = c; } else { width = 0; chars = 1; *s = c; } } else { width = 1; chars = 1; *s = c; } input_position += width; return chars; } /* We've just printed some files and need to clean up things before looking for more options and printing the next batch of files. Free everything we've xmalloc'ed, except `header'. */ static void cleanup () { if (number_buff) free (number_buff); if (clump_buff) free (clump_buff); if (column_vector) free (column_vector); if (line_vector) free (line_vector); if (end_vector) free (end_vector); if (buff) free (buff); } /* Complain, print a usage message, and die. */ 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 ("\ Paginate or columnate FILE(s) for printing.\n\ \n\ +PAGE begin printing with page PAGE\n\ -COLUMN produce COLUMN-column output and print columns down\n\ -F, -f simulate formfeed with newlines on output\n\ -a print columns across rather than down\n\ -b balance columns on the last page\n\ -c use hat notation (^G) and octal backslash notation\n\ -d double space the output\n\ -e[CHAR[WIDTH]] expand input CHARs (TABs) to tab WIDTH (8)\n\ -h HEADER use HEADER instead of filename in page headers\n\ -i[CHAR[WIDTH]] replace spaces with CHARs (TABs) to tab WIDTH (8)\n\ -l PAGE_LENGTH set the page length to PAGE_LENGTH (66) lines\n\ -m print all files in parallel, one in each column\n\ -n[SEP[DIGITS]] number lines, use DIGITS (5) digits, then SEP (TAB)\n\ -o MARGIN offset each line with MARGIN spaces (do not affect -w)\n\ -r inhibit warning when a file cannot be opened\n\ -s[SEP] separate columns by character SEP (TAB)\n\ -t inhibit 5-line page headers and trailers\n\ -v use octal backslash notation\n\ -w PAGE_WIDTH set page width to PAGE_WIDTH (72) columns\n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ -t implied by -l N when N < 10. Without -s, columns are separated by\n\ spaces. With no FILE, or when FILE is -, read standard input.\n\ "); } exit (status); } textutils-1.12/src/sort.c100666 74504 13 127115 5770310631 14557 0ustar meyeringuser/* sort - sort lines of text (with all kinds of options). Copyright (C) 1988, 1991, 1992, 1993, 1994, 1995 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. Written December 1988 by Mike Haertel. The author may be reached (Email) at the address mike@gnu.ai.mit.edu, or (US mail) as Mike Haertel c/o Free Software Foundation. */ #include /* Get isblank from GNU libc. */ #define _GNU_SOURCE #include #include #include #include "system.h" #include "version.h" #include "long-options.h" #include "error.h" #ifdef _POSIX_VERSION #include #else #ifndef UCHAR_MAX #define UCHAR_MAX 255 #endif #endif #ifndef STDC_HEADERS char *malloc (); char *realloc (); void free (); #endif static void usage (); #define min(a, b) ((a) < (b) ? (a) : (b)) #define UCHAR_LIM (UCHAR_MAX + 1) #define UCHAR(c) ((unsigned char) (c)) #ifndef DEFAULT_TMPDIR #define DEFAULT_TMPDIR "/tmp" #endif /* The kind of blanks for '-b' to skip in various options. */ enum blanktype { bl_start, bl_end, bl_both }; /* The name this program was run with. */ char *program_name; /* Table of digits. */ static int digits[UCHAR_LIM]; /* Table of white space. */ static int blanks[UCHAR_LIM]; /* Table of non-printing characters. */ static int nonprinting[UCHAR_LIM]; /* Table of non-dictionary characters (not letters, digits, or blanks). */ static int nondictionary[UCHAR_LIM]; /* Translation table folding lower case to upper. */ static char fold_toupper[UCHAR_LIM]; /* Table mapping 3-letter month names to integers. Alphabetic order allows binary search. */ static struct month { char *name; int val; } const monthtab[] = { {"APR", 4}, {"AUG", 8}, {"DEC", 12}, {"FEB", 2}, {"JAN", 1}, {"JUL", 7}, {"JUN", 6}, {"MAR", 3}, {"MAY", 5}, {"NOV", 11}, {"OCT", 10}, {"SEP", 9} }; /* During the merge phase, the number of files to merge at once. */ #define NMERGE 16 /* Initial buffer size for in core sorting. Will not grow unless a line longer than this is seen. */ static int sortalloc = 512 * 1024; /* Initial buffer size for in core merge buffers. Bear in mind that up to NMERGE * mergealloc bytes may be allocated for merge buffers. */ static int mergealloc = 16 * 1024; /* Guess of average line length. */ static int linelength = 30; /* Maximum number of elements for the array(s) of struct line's, in bytes. */ #define LINEALLOC (256 * 1024) /* Prefix for temporary file names. */ static char *temp_file_prefix; /* Flag to reverse the order of all comparisons. */ static int reverse; /* Flag for stable sort. This turns off the last ditch bytewise comparison of lines, and instead leaves lines in the same order they were read if all keys compare equal. */ static int stable; /* Tab character separating fields. If NUL, then fields are separated by the empty string between a non-whitespace character and a whitespace character. */ static char tab; /* Flag to remove consecutive duplicate lines from the output. Only the last of a sequence of equal lines will be output. */ static int unique; /* Nonzero if any of the input files are the standard input. */ static int have_read_stdin; /* Lines are held in core as counted strings. */ struct line { char *text; /* Text of the line. */ int length; /* Length not including final newline. */ char *keybeg; /* Start of first key. */ char *keylim; /* Limit of first key. */ }; /* Arrays of lines. */ struct lines { struct line *lines; /* Dynamically allocated array of lines. */ int used; /* Number of slots used. */ int alloc; /* Number of slots allocated. */ int limit; /* Max number of slots to allocate. */ }; /* Input buffers. */ struct buffer { char *buf; /* Dynamically allocated buffer. */ int used; /* Number of bytes used. */ int alloc; /* Number of bytes allocated. */ int left; /* Number of bytes left after line parsing. */ }; /* Lists of key field comparisons to be tried. */ static struct keyfield { int sword; /* Zero-origin 'word' to start at. */ int schar; /* Additional characters to skip. */ int skipsblanks; /* Skip leading white space at start. */ int eword; /* Zero-origin first word after field. */ int echar; /* Additional characters in field. */ int skipeblanks; /* Skip trailing white space at finish. */ int *ignore; /* Boolean array of characters to ignore. */ char *translate; /* Translation applied to characters. */ int numeric; /* Flag for numeric comparison. */ int month; /* Flag for comparison by month name. */ int reverse; /* Reverse the sense of comparison. */ struct keyfield *next; /* Next keyfield to try. */ } keyhead; /* The list of temporary files. */ static struct tempnode { char *name; struct tempnode *next; } temphead; /* Clean up any remaining temporary files. */ static void cleanup () { struct tempnode *node; for (node = temphead.next; node; node = node->next) unlink (node->name); } /* Allocate N bytes of memory dynamically, with error checking. */ char * xmalloc (n) unsigned n; { char *p; p = malloc (n); if (p == 0) { error (0, 0, "virtual memory exhausted"); cleanup (); exit (2); } 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. */ char * xrealloc (p, n) char *p; unsigned n; { if (p == 0) return xmalloc (n); if (n == 0) { free (p); return 0; } p = realloc (p, n); if (p == 0) { error (0, 0, "virtual memory exhausted"); cleanup (); exit (2); } return p; } static FILE * xfopen (file, how) char *file, *how; { FILE *fp = strcmp (file, "-") ? fopen (file, how) : stdin; if (fp == 0) { error (0, errno, "%s", file); cleanup (); exit (2); } if (fp == stdin) have_read_stdin = 1; return fp; } static void xfclose (fp) FILE *fp; { if (fp == stdin) { /* Allow reading stdin from tty more than once. */ if (feof (fp)) clearerr (fp); } else if (fp == stdout) { if (fflush (fp) != 0) { error (0, errno, "flushing file"); cleanup (); exit (2); } } else { if (fclose (fp) != 0) { error (0, errno, "error closing file"); cleanup (); exit (2); } } } static void xfwrite (buf, size, nelem, fp) char *buf; int size, nelem; FILE *fp; { if (fwrite (buf, size, nelem, fp) != nelem) { error (0, errno, "write error"); cleanup (); exit (2); } } /* Return a name for a temporary file. */ static char * tempname () { static int seq; int len = strlen (temp_file_prefix); char *name = xmalloc (len + 16); struct tempnode *node = (struct tempnode *) xmalloc (sizeof (struct tempnode)); sprintf (name, "%s%ssort%5.5d%5.5d", temp_file_prefix, (len && temp_file_prefix[len - 1] != '/') ? "/" : "", (unsigned int) getpid () & 0xffff, ++seq); node->name = name; node->next = temphead.next; temphead.next = node; return name; } /* Search through the list of temporary files for NAME; remove it if it is found on the list. */ static void zaptemp (name) char *name; { struct tempnode *node, *temp; for (node = &temphead; node->next; node = node->next) if (!strcmp (name, node->next->name)) break; if (node->next) { temp = node->next; unlink (temp->name); free (temp->name); node->next = temp->next; free ((char *) temp); } } /* Initialize the character class tables. */ static void inittables () { int i; for (i = 0; i < UCHAR_LIM; ++i) { if (ISBLANK (i)) blanks[i] = 1; if (ISDIGIT (i)) digits[i] = 1; if (!ISPRINT (i)) nonprinting[i] = 1; if (!ISALNUM (i) && !ISBLANK (i)) nondictionary[i] = 1; if (ISLOWER (i)) fold_toupper[i] = toupper (i); else fold_toupper[i] = i; } } /* Initialize BUF, allocating ALLOC bytes initially. */ static void initbuf (buf, alloc) struct buffer *buf; int alloc; { buf->alloc = alloc; buf->buf = xmalloc (buf->alloc); buf->used = buf->left = 0; } /* Fill BUF reading from FP, moving buf->left bytes from the end of buf->buf to the beginning first. If EOF is reached and the file wasn't terminated by a newline, supply one. Return a count of bytes buffered. */ static int fillbuf (buf, fp) struct buffer *buf; FILE *fp; { int cc; memmove (buf->buf, buf->buf + buf->used - buf->left, buf->left); buf->used = buf->left; while (!feof (fp) && (buf->used == 0 || !memchr (buf->buf, '\n', buf->used))) { if (buf->used == buf->alloc) { buf->alloc *= 2; buf->buf = xrealloc (buf->buf, buf->alloc); } cc = fread (buf->buf + buf->used, 1, buf->alloc - buf->used, fp); if (ferror (fp)) { error (0, errno, "read error"); cleanup (); exit (2); } buf->used += cc; } if (feof (fp) && buf->used && buf->buf[buf->used - 1] != '\n') { if (buf->used == buf->alloc) { buf->alloc *= 2; buf->buf = xrealloc (buf->buf, buf->alloc); } buf->buf[buf->used++] = '\n'; } return buf->used; } /* Initialize LINES, allocating space for ALLOC lines initially. LIMIT is the maximum possible number of lines to allocate space for, ever. */ static void initlines (lines, alloc, limit) struct lines *lines; int alloc; int limit; { lines->alloc = alloc; lines->lines = (struct line *) xmalloc (lines->alloc * sizeof (struct line)); lines->used = 0; lines->limit = limit; } /* Return a pointer to the first character of the field specified by KEY in LINE. */ static char * begfield (line, key) struct line *line; struct keyfield *key; { register char *ptr = line->text, *lim = ptr + line->length; register int sword = key->sword, schar = key->schar; if (tab) while (ptr < lim && sword--) { while (ptr < lim && *ptr != tab) ++ptr; if (ptr < lim) ++ptr; } else while (ptr < lim && sword--) { while (ptr < lim && blanks[UCHAR (*ptr)]) ++ptr; while (ptr < lim && !blanks[UCHAR (*ptr)]) ++ptr; } if (key->skipsblanks) while (ptr < lim && blanks[UCHAR (*ptr)]) ++ptr; while (ptr < lim && schar--) ++ptr; return ptr; } /* Return the limit of (a pointer to the first character after) the field in LINE specified by KEY. */ static char * limfield (line, key) struct line *line; struct keyfield *key; { register char *ptr = line->text, *lim = ptr + line->length; register int eword = key->eword, echar = key->echar; if (tab) while (ptr < lim && eword--) { while (ptr < lim && *ptr != tab) ++ptr; if (ptr < lim && (eword || key->skipeblanks)) ++ptr; } else while (ptr < lim && eword--) { while (ptr < lim && blanks[UCHAR (*ptr)]) ++ptr; while (ptr < lim && !blanks[UCHAR (*ptr)]) ++ptr; } if (key->skipeblanks) while (ptr < lim && blanks[UCHAR (*ptr)]) ++ptr; while (ptr < lim && echar--) ++ptr; return ptr; } /* Find the lines in BUF, storing pointers and lengths in LINES. Also replace newlines with NULs. */ static void findlines (buf, lines) struct buffer *buf; struct lines *lines; { register char *beg = buf->buf, *lim = buf->buf + buf->used, *ptr; struct keyfield *key = keyhead.next; lines->used = 0; while (beg < lim && (ptr = memchr (beg, '\n', lim - beg)) && lines->used < lines->limit) { /* There are various places in the code that rely on a NUL being at the end of in-core lines; NULs inside the lines will not cause trouble, though. */ *ptr = '\0'; if (lines->used == lines->alloc) { lines->alloc *= 2; lines->lines = (struct line *) xrealloc ((char *) lines->lines, lines->alloc * sizeof (struct line)); } lines->lines[lines->used].text = beg; lines->lines[lines->used].length = ptr - beg; /* Precompute the position of the first key for efficiency. */ if (key) { if (key->eword >= 0) lines->lines[lines->used].keylim = limfield (&lines->lines[lines->used], key); else lines->lines[lines->used].keylim = ptr; if (key->sword >= 0) lines->lines[lines->used].keybeg = begfield (&lines->lines[lines->used], key); else { if (key->skipsblanks) while (blanks[UCHAR (*beg)]) ++beg; lines->lines[lines->used].keybeg = beg; } } else { lines->lines[lines->used].keybeg = 0; lines->lines[lines->used].keylim = 0; } ++lines->used; beg = ptr + 1; } buf->left = lim - beg; } /* Compare strings A and B containing decimal fractions < 1. Each string should begin with a decimal point followed immediately by the digits of the fraction. Strings not of this form are considered to be zero. */ static int fraccompare (a, b) register char *a, *b; { register tmpa = UCHAR (*a), tmpb = UCHAR (*b); if (tmpa == '.' && tmpb == '.') { do tmpa = UCHAR (*++a), tmpb = UCHAR (*++b); while (tmpa == tmpb && digits[tmpa]); if (digits[tmpa] && digits[tmpb]) return tmpa - tmpb; if (digits[tmpa]) { while (tmpa == '0') tmpa = UCHAR (*++a); if (digits[tmpa]) return 1; return 0; } if (digits[tmpb]) { while (tmpb == '0') tmpb = UCHAR (*++b); if (digits[tmpb]) return -1; return 0; } return 0; } else if (tmpa == '.') { do tmpa = UCHAR (*++a); while (tmpa == '0'); if (digits[tmpa]) return 1; return 0; } else if (tmpb == '.') { do tmpb = UCHAR (*++b); while (tmpb == '0'); if (digits[tmpb]) return -1; return 0; } return 0; } /* Compare strings A and B as numbers without explicitly converting them to machine numbers. Comparatively slow for short strings, but asymptotically hideously fast. */ static int numcompare (a, b) register char *a, *b; { register int tmpa, tmpb, loga, logb, tmp; tmpa = UCHAR (*a), tmpb = UCHAR (*b); while (blanks[tmpa]) tmpa = UCHAR (*++a); while (blanks[tmpb]) tmpb = UCHAR (*++b); if (tmpa == '-') { tmpa = UCHAR (*++a); if (tmpb != '-') { if (digits[tmpa] && digits[tmpb]) return -1; return 0; } tmpb = UCHAR (*++b); while (tmpa == '0') tmpa = UCHAR (*++a); while (tmpb == '0') tmpb = UCHAR (*++b); while (tmpa == tmpb && digits[tmpa]) tmpa = UCHAR (*++a), tmpb = UCHAR (*++b); if ((tmpa == '.' && !digits[tmpb]) || (tmpb == '.' && !digits[tmpa])) return -fraccompare (a, b); if (digits[tmpa]) for (loga = 1; digits[UCHAR (*++a)]; ++loga) ; else loga = 0; if (digits[tmpb]) for (logb = 1; digits[UCHAR (*++b)]; ++logb) ; else logb = 0; if ((tmp = logb - loga) != 0) return tmp; if (!loga) return 0; return tmpb - tmpa; } else if (tmpb == '-') { if (digits[UCHAR (tmpa)] && digits[UCHAR (*++b)]) return 1; return 0; } else { while (tmpa == '0') tmpa = UCHAR (*++a); while (tmpb == '0') tmpb = UCHAR (*++b); while (tmpa == tmpb && digits[tmpa]) tmpa = UCHAR (*++a), tmpb = UCHAR (*++b); if ((tmpa == '.' && !digits[tmpb]) || (tmpb == '.' && !digits[tmpa])) return fraccompare (a, b); if (digits[tmpa]) for (loga = 1; digits[UCHAR (*++a)]; ++loga) ; else loga = 0; if (digits[tmpb]) for (logb = 1; digits[UCHAR (*++b)]; ++logb) ; else logb = 0; if ((tmp = loga - logb) != 0) return tmp; if (!loga) return 0; return tmpa - tmpb; } } /* Return an integer <= 12 associated with month name S with length LEN, 0 if the name in S is not recognized. */ static int getmonth (s, len) char *s; int len; { char month[4]; register int i, lo = 0, hi = 12; while (len > 0 && blanks[UCHAR(*s)]) ++s, --len; if (len < 3) return 0; for (i = 0; i < 3; ++i) month[i] = fold_toupper[UCHAR (s[i])]; month[3] = '\0'; while (hi - lo > 1) if (strcmp (month, monthtab[(lo + hi) / 2].name) < 0) hi = (lo + hi) / 2; else lo = (lo + hi) / 2; if (!strcmp (month, monthtab[lo].name)) return monthtab[lo].val; return 0; } /* Compare two lines A and B trying every key in sequence until there are no more keys or a difference is found. */ static int keycompare (a, b) struct line *a, *b; { register char *texta, *textb, *lima, *limb, *translate; register int *ignore; struct keyfield *key; int diff = 0, iter = 0, lena, lenb; for (key = keyhead.next; key; key = key->next, ++iter) { ignore = key->ignore; translate = key->translate; /* Find the beginning and limit of each field. */ if (iter || a->keybeg == NULL || b->keybeg == NULL) { if (key->eword >= 0) lima = limfield (a, key), limb = limfield (b, key); else lima = a->text + a->length, limb = b->text + b->length; if (key->sword >= 0) texta = begfield (a, key), textb = begfield (b, key); else { texta = a->text, textb = b->text; if (key->skipsblanks) { while (texta < lima && blanks[UCHAR (*texta)]) ++texta; while (textb < limb && blanks[UCHAR (*textb)]) ++textb; } } } else { /* For the first iteration only, the key positions have been precomputed for us. */ texta = a->keybeg, lima = a->keylim; textb = b->keybeg, limb = b->keylim; } /* Find the lengths. */ lena = lima - texta, lenb = limb - textb; if (lena < 0) lena = 0; if (lenb < 0) lenb = 0; /* Actually compare the fields. */ if (key->numeric) { if (*lima || *limb) { char savea = *lima, saveb = *limb; *lima = *limb = '\0'; diff = numcompare (texta, textb); *lima = savea, *limb = saveb; } else diff = numcompare (texta, textb); if (diff) return key->reverse ? -diff : diff; continue; } else if (key->month) { diff = getmonth (texta, lena) - getmonth (textb, lenb); if (diff) return key->reverse ? -diff : diff; continue; } else if (ignore && translate) while (texta < lima && textb < limb) { while (texta < lima && ignore[UCHAR (*texta)]) ++texta; while (textb < limb && ignore[UCHAR (*textb)]) ++textb; if (texta < lima && textb < limb && translate[UCHAR (*texta++)] != translate[UCHAR (*textb++)]) { diff = translate[UCHAR (*--texta)] - translate[UCHAR (*--textb)]; break; } else if (texta == lima && textb < limb) diff = -1; else if (texta < lima && textb == limb) diff = 1; } else if (ignore) while (texta < lima && textb < limb) { while (texta < lima && ignore[UCHAR (*texta)]) ++texta; while (textb < limb && ignore[UCHAR (*textb)]) ++textb; if (texta < lima && textb < limb && *texta++ != *textb++) { diff = *--texta - *--textb; break; } else if (texta == lima && textb < limb) diff = -1; else if (texta < lima && textb == limb) diff = 1; } else if (translate) while (texta < lima && textb < limb) { if (translate[UCHAR (*texta++)] != translate[UCHAR (*textb++)]) { diff = translate[UCHAR (*--texta)] - translate[UCHAR (*--textb)]; break; } } else diff = memcmp (texta, textb, min (lena, lenb)); if (diff) return key->reverse ? -diff : diff; if ((diff = lena - lenb) != 0) return key->reverse ? -diff : diff; } return 0; } /* Compare two lines A and B, returning negative, zero, or positive depending on whether A compares less than, equal to, or greater than B. */ static int compare (a, b) register struct line *a, *b; { int diff, tmpa, tmpb, mini; /* First try to compare on the specified keys (if any). The only two cases with no key at all are unadorned sort, and unadorned sort -r. */ if (keyhead.next) { diff = keycompare (a, b); if (diff != 0) return diff; if (unique || stable) return 0; } /* If the keys all compare equal (or no keys were specified) fall through to the default byte-by-byte comparison. */ tmpa = a->length, tmpb = b->length; mini = min (tmpa, tmpb); if (mini == 0) diff = tmpa - tmpb; else { char *ap = a->text, *bp = b->text; diff = UCHAR (*ap) - UCHAR (*bp); if (diff == 0) { diff = memcmp (ap, bp, mini); if (diff == 0) diff = tmpa - tmpb; } } return reverse ? -diff : diff; } /* Check that the lines read from the given FP come in order. Return 1 if they do and 0 if there is a disorder. */ static int checkfp (fp) FILE *fp; { struct buffer buf; /* Input buffer. */ struct lines lines; /* Lines scanned from the buffer. */ struct line *prev_line; /* Pointer to previous line. */ struct line temp; /* Copy of previous line. */ int cc; /* Character count. */ int cmp; /* Result of calling compare. */ int alloc, i, success = 1; initbuf (&buf, mergealloc); initlines (&lines, mergealloc / linelength + 1, LINEALLOC / ((NMERGE + NMERGE) * sizeof (struct line))); alloc = linelength; temp.text = xmalloc (alloc); cc = fillbuf (&buf, fp); findlines (&buf, &lines); if (cc) do { /* Compare each line in the buffer with its successor. */ for (i = 0; i < lines.used - 1; ++i) { cmp = compare (&lines.lines[i], &lines.lines[i + 1]); if ((unique && cmp >= 0) || (cmp > 0)) { success = 0; goto finish; } } /* Save the last line of the buffer and refill the buffer. */ prev_line = lines.lines + lines.used - 1; if (prev_line->length > alloc) { while (prev_line->length + 1 > alloc) alloc *= 2; temp.text = xrealloc (temp.text, alloc); } memcpy (temp.text, prev_line->text, prev_line->length + 1); temp.length = prev_line->length; temp.keybeg = temp.text + (prev_line->keybeg - prev_line->text); temp.keylim = temp.text + (prev_line->keylim - prev_line->text); cc = fillbuf (&buf, fp); if (cc) { findlines (&buf, &lines); /* Make sure the line saved from the old buffer contents is less than or equal to the first line of the new buffer. */ cmp = compare (&temp, &lines.lines[0]); if ((unique && cmp >= 0) || (cmp > 0)) { success = 0; break; } } } while (cc); finish: xfclose (fp); free (buf.buf); free ((char *) lines.lines); free (temp.text); return success; } /* Merge lines from FPS onto OFP. NFPS cannot be greater than NMERGE. Close FPS before returning. */ static void mergefps (fps, nfps, ofp) FILE *fps[], *ofp; register int nfps; { struct buffer buffer[NMERGE]; /* Input buffers for each file. */ struct lines lines[NMERGE]; /* Line tables for each buffer. */ struct line saved; /* Saved line for unique check. */ int savedflag = 0; /* True if there is a saved line. */ int savealloc; /* Size allocated for the saved line. */ int cur[NMERGE]; /* Current line in each line table. */ int ord[NMERGE]; /* Table representing a permutation of fps, such that lines[ord[0]].lines[cur[ord[0]]] is the smallest line and will be next output. */ register int i, j, t; /* Allocate space for a saved line if necessary. */ if (unique) { savealloc = linelength; saved.text = xmalloc (savealloc); } /* Read initial lines from each input file. */ for (i = 0; i < nfps; ++i) { initbuf (&buffer[i], mergealloc); /* If a file is empty, eliminate it from future consideration. */ while (i < nfps && !fillbuf (&buffer[i], fps[i])) { xfclose (fps[i]); --nfps; for (j = i; j < nfps; ++j) fps[j] = fps[j + 1]; } if (i == nfps) free (buffer[i].buf); else { initlines (&lines[i], mergealloc / linelength + 1, LINEALLOC / ((NMERGE + NMERGE) * sizeof (struct line))); findlines (&buffer[i], &lines[i]); cur[i] = 0; } } /* Set up the ord table according to comparisons among input lines. Since this only reorders two items if one is strictly greater than the other, it is stable. */ for (i = 0; i < nfps; ++i) ord[i] = i; for (i = 1; i < nfps; ++i) if (compare (&lines[ord[i - 1]].lines[cur[ord[i - 1]]], &lines[ord[i]].lines[cur[ord[i]]]) > 0) t = ord[i - 1], ord[i - 1] = ord[i], ord[i] = t, i = 0; /* Repeatedly output the smallest line until no input remains. */ while (nfps) { /* If uniqified output is turned on, output only the first of an identical series of lines. */ if (unique) { if (savedflag && compare (&saved, &lines[ord[0]].lines[cur[ord[0]]])) { xfwrite (saved.text, 1, saved.length, ofp); putc ('\n', ofp); savedflag = 0; } if (!savedflag) { if (savealloc < lines[ord[0]].lines[cur[ord[0]]].length + 1) { while (savealloc < lines[ord[0]].lines[cur[ord[0]]].length + 1) savealloc *= 2; saved.text = xrealloc (saved.text, savealloc); } saved.length = lines[ord[0]].lines[cur[ord[0]]].length; memcpy (saved.text, lines[ord[0]].lines[cur[ord[0]]].text, saved.length + 1); if (lines[ord[0]].lines[cur[ord[0]]].keybeg != NULL) { saved.keybeg = saved.text + (lines[ord[0]].lines[cur[ord[0]]].keybeg - lines[ord[0]].lines[cur[ord[0]]].text); } if (lines[ord[0]].lines[cur[ord[0]]].keylim != NULL) { saved.keylim = saved.text + (lines[ord[0]].lines[cur[ord[0]]].keylim - lines[ord[0]].lines[cur[ord[0]]].text); } savedflag = 1; } } else { xfwrite (lines[ord[0]].lines[cur[ord[0]]].text, 1, lines[ord[0]].lines[cur[ord[0]]].length, ofp); putc ('\n', ofp); } /* Check if we need to read more lines into core. */ if (++cur[ord[0]] == lines[ord[0]].used) if (fillbuf (&buffer[ord[0]], fps[ord[0]])) { findlines (&buffer[ord[0]], &lines[ord[0]]); cur[ord[0]] = 0; } else { /* We reached EOF on fps[ord[0]]. */ for (i = 1; i < nfps; ++i) if (ord[i] > ord[0]) --ord[i]; --nfps; xfclose (fps[ord[0]]); free (buffer[ord[0]].buf); free ((char *) lines[ord[0]].lines); for (i = ord[0]; i < nfps; ++i) { fps[i] = fps[i + 1]; buffer[i] = buffer[i + 1]; lines[i] = lines[i + 1]; cur[i] = cur[i + 1]; } for (i = 0; i < nfps; ++i) ord[i] = ord[i + 1]; continue; } /* The new line just read in may be larger than other lines already in core; push it back in the queue until we encounter a line larger than it. */ for (i = 1; i < nfps; ++i) { t = compare (&lines[ord[0]].lines[cur[ord[0]]], &lines[ord[i]].lines[cur[ord[i]]]); if (!t) t = ord[0] - ord[i]; if (t < 0) break; } t = ord[0]; for (j = 1; j < i; ++j) ord[j - 1] = ord[j]; ord[i - 1] = t; } if (unique && savedflag) { xfwrite (saved.text, 1, saved.length, ofp); putc ('\n', ofp); free (saved.text); } } /* Sort the array LINES with NLINES members, using TEMP for temporary space. */ static void sortlines (lines, nlines, temp) struct line *lines, *temp; int nlines; { register struct line *lo, *hi, *t; register int nlo, nhi; if (nlines == 2) { if (compare (&lines[0], &lines[1]) > 0) *temp = lines[0], lines[0] = lines[1], lines[1] = *temp; return; } nlo = nlines / 2; lo = lines; nhi = nlines - nlo; hi = lines + nlo; if (nlo > 1) sortlines (lo, nlo, temp); if (nhi > 1) sortlines (hi, nhi, temp); t = temp; while (nlo && nhi) if (compare (lo, hi) <= 0) *t++ = *lo++, --nlo; else *t++ = *hi++, --nhi; while (nlo--) *t++ = *lo++; for (lo = lines, nlo = nlines - nhi, t = temp; nlo; --nlo) *lo++ = *t++; } /* Check that each of the NFILES FILES is ordered. Return a count of disordered files. */ static int check (files, nfiles) char *files[]; int nfiles; { int i, disorders = 0; FILE *fp; for (i = 0; i < nfiles; ++i) { fp = xfopen (files[i], "r"); if (!checkfp (fp)) { printf ("%s: disorder on %s\n", program_name, files[i]); ++disorders; } } return disorders; } /* Merge NFILES FILES onto OFP. */ static void merge (files, nfiles, ofp) char *files[]; int nfiles; FILE *ofp; { int i, j, t; char *temp; FILE *fps[NMERGE], *tfp; while (nfiles > NMERGE) { t = 0; for (i = 0; i < nfiles / NMERGE; ++i) { for (j = 0; j < NMERGE; ++j) fps[j] = xfopen (files[i * NMERGE + j], "r"); tfp = xfopen (temp = tempname (), "w"); mergefps (fps, NMERGE, tfp); xfclose (tfp); for (j = 0; j < NMERGE; ++j) zaptemp (files[i * NMERGE + j]); files[t++] = temp; } for (j = 0; j < nfiles % NMERGE; ++j) fps[j] = xfopen (files[i * NMERGE + j], "r"); tfp = xfopen (temp = tempname (), "w"); mergefps (fps, nfiles % NMERGE, tfp); xfclose (tfp); for (j = 0; j < nfiles % NMERGE; ++j) zaptemp (files[i * NMERGE + j]); files[t++] = temp; nfiles = t; } for (i = 0; i < nfiles; ++i) fps[i] = xfopen (files[i], "r"); mergefps (fps, i, ofp); for (i = 0; i < nfiles; ++i) zaptemp (files[i]); } /* Sort NFILES FILES onto OFP. */ static void sort (files, nfiles, ofp) char **files; int nfiles; FILE *ofp; { struct buffer buf; struct lines lines; struct line *tmp; int i, ntmp; FILE *fp, *tfp; struct tempnode *node; int ntemp = 0; char **tempfiles; initbuf (&buf, sortalloc); initlines (&lines, sortalloc / linelength + 1, LINEALLOC / sizeof (struct line)); ntmp = lines.alloc; tmp = (struct line *) xmalloc (ntmp * sizeof (struct line)); while (nfiles--) { fp = xfopen (*files++, "r"); while (fillbuf (&buf, fp)) { findlines (&buf, &lines); if (lines.used > ntmp) { while (lines.used > ntmp) ntmp *= 2; tmp = (struct line *) xrealloc ((char *) tmp, ntmp * sizeof (struct line)); } sortlines (lines.lines, lines.used, tmp); if (feof (fp) && !nfiles && !ntemp && !buf.left) tfp = ofp; else { ++ntemp; tfp = xfopen (tempname (), "w"); } for (i = 0; i < lines.used; ++i) if (!unique || i == 0 || compare (&lines.lines[i], &lines.lines[i - 1])) { xfwrite (lines.lines[i].text, 1, lines.lines[i].length, tfp); putc ('\n', tfp); } if (tfp != ofp) xfclose (tfp); } xfclose (fp); } free (buf.buf); free ((char *) lines.lines); free ((char *) tmp); if (ntemp) { tempfiles = (char **) xmalloc (ntemp * sizeof (char *)); i = ntemp; for (node = temphead.next; i > 0; node = node->next) tempfiles[--i] = node->name; merge (tempfiles, ntemp, ofp); free ((char *) tempfiles); } } /* Insert key KEY at the end of the list (`keyhead'). */ static void insertkey (key) struct keyfield *key; { struct keyfield *k = &keyhead; while (k->next) k = k->next; k->next = key; key->next = NULL; } static void badfieldspec (s) char *s; { error (2, 0, "invalid field specification `%s'", s); } /* Handle interrupts and hangups. */ static void sighandler (sig) int sig; { #ifdef _POSIX_VERSION struct sigaction sigact; sigact.sa_handler = SIG_DFL; sigemptyset (&sigact.sa_mask); sigact.sa_flags = 0; sigaction (sig, &sigact, NULL); #else /* !_POSIX_VERSION */ signal (sig, SIG_DFL); #endif /* _POSIX_VERSION */ cleanup (); kill (getpid (), sig); } /* Set the ordering options for KEY specified in S. Return the address of the first character in S that is not a valid ordering option. BLANKTYPE is the kind of blanks that 'b' should skip. */ static char * set_ordering (s, key, blanktype) register char *s; struct keyfield *key; enum blanktype blanktype; { while (*s) { switch (*s) { case 'b': if (blanktype == bl_start || blanktype == bl_both) key->skipsblanks = 1; if (blanktype == bl_end || blanktype == bl_both) key->skipeblanks = 1; break; case 'd': key->ignore = nondictionary; break; case 'f': key->translate = fold_toupper; break; #if 0 case 'g': /* Reserved for comparing floating-point numbers. */ break; #endif case 'i': key->ignore = nonprinting; break; case 'M': key->month = 1; break; case 'n': key->numeric = 1; if (blanktype == bl_start || blanktype == bl_both) key->skipsblanks = 1; if (blanktype == bl_end || blanktype == bl_both) key->skipeblanks = 1; break; case 'r': key->reverse = 1; break; default: return s; } ++s; } return s; } void main (argc, argv) int argc; char *argv[]; { struct keyfield *key = NULL, gkey; char *s; int i, t, t2; int checkonly = 0, mergeonly = 0, nfiles = 0; char *minus = "-", *outfile = minus, **files, *tmp; FILE *ofp; #ifdef _POSIX_VERSION struct sigaction oldact, newact; #endif /* _POSIX_VERSION */ program_name = argv[0]; parse_long_options (argc, argv, "sort", version_string, usage); have_read_stdin = 0; inittables (); temp_file_prefix = getenv ("TMPDIR"); if (temp_file_prefix == NULL) temp_file_prefix = DEFAULT_TMPDIR; #ifdef _POSIX_VERSION newact.sa_handler = sighandler; sigemptyset (&newact.sa_mask); newact.sa_flags = 0; sigaction (SIGINT, NULL, &oldact); if (oldact.sa_handler != SIG_IGN) sigaction (SIGINT, &newact, NULL); sigaction (SIGHUP, NULL, &oldact); if (oldact.sa_handler != SIG_IGN) sigaction (SIGHUP, &newact, NULL); sigaction (SIGPIPE, NULL, &oldact); if (oldact.sa_handler != SIG_IGN) sigaction (SIGPIPE, &newact, NULL); sigaction (SIGTERM, NULL, &oldact); if (oldact.sa_handler != SIG_IGN) sigaction (SIGTERM, &newact, NULL); #else /* !_POSIX_VERSION */ if (signal (SIGINT, SIG_IGN) != SIG_IGN) signal (SIGINT, sighandler); if (signal (SIGHUP, SIG_IGN) != SIG_IGN) signal (SIGHUP, sighandler); if (signal (SIGPIPE, SIG_IGN) != SIG_IGN) signal (SIGPIPE, sighandler); if (signal (SIGTERM, SIG_IGN) != SIG_IGN) signal (SIGTERM, sighandler); #endif /* !_POSIX_VERSION */ gkey.sword = gkey.eword = -1; gkey.ignore = NULL; gkey.translate = NULL; gkey.numeric = gkey.month = gkey.reverse = 0; gkey.skipsblanks = gkey.skipeblanks = 0; files = (char **) xmalloc (sizeof (char *) * argc); for (i = 1; i < argc; ++i) { if (argv[i][0] == '+') { if (key) insertkey (key); key = (struct keyfield *) xmalloc (sizeof (struct keyfield)); key->eword = -1; key->ignore = NULL; key->translate = NULL; key->skipsblanks = key->skipeblanks = 0; key->numeric = key->month = key->reverse = 0; s = argv[i] + 1; if (!digits[UCHAR (*s)]) badfieldspec (argv[i]); for (t = 0; digits[UCHAR (*s)]; ++s) t = 10 * t + *s - '0'; t2 = 0; if (*s == '.') for (++s; digits[UCHAR (*s)]; ++s) t2 = 10 * t2 + *s - '0'; if (t2 || t) { key->sword = t; key->schar = t2; } else key->sword = -1; s = set_ordering (s, key, bl_start); if (*s) badfieldspec (argv[i]); } else if (argv[i][0] == '-' && argv[i][1]) { s = argv[i] + 1; if (digits[UCHAR (*s)]) { if (!key) usage (2); for (t = 0; digits[UCHAR (*s)]; ++s) t = t * 10 + *s - '0'; t2 = 0; if (*s == '.') for (++s; digits[UCHAR (*s)]; ++s) t2 = t2 * 10 + *s - '0'; key->eword = t; key->echar = t2; s = set_ordering (s, key, bl_end); if (*s) badfieldspec (argv[i]); insertkey (key); key = NULL; } else while (*s) { s = set_ordering (s, &gkey, bl_both); switch (*s) { case '\0': break; case 'c': checkonly = 1; break; case 'k': if (s[1]) ++s; else { if (i == argc - 1) error (2, 0, "option `-k' requires an argument"); else s = argv[++i]; } if (key) insertkey (key); key = (struct keyfield *) xmalloc (sizeof (struct keyfield)); key->eword = -1; key->ignore = NULL; key->translate = NULL; key->skipsblanks = key->skipeblanks = 0; key->numeric = key->month = key->reverse = 0; /* Get POS1. */ if (!digits[UCHAR (*s)]) badfieldspec (argv[i]); for (t = 0; digits[UCHAR (*s)]; ++s) t = 10 * t + *s - '0'; if (t) t--; t2 = 0; if (*s == '.') { for (++s; digits[UCHAR (*s)]; ++s) t2 = 10 * t2 + *s - '0'; if (t2) t2--; } if (t2 || t) { key->sword = t; key->schar = t2; } else key->sword = -1; s = set_ordering (s, key, bl_start); if (*s && *s != ',') badfieldspec (argv[i]); else if (*s++) { /* Get POS2. */ for (t = 0; digits[UCHAR (*s)]; ++s) t = t * 10 + *s - '0'; if (t) t--; t2 = 0; if (*s == '.') { for (++s; digits[UCHAR (*s)]; ++s) t2 = t2 * 10 + *s - '0'; if (t2) t2--; } key->eword = t; key->echar = t2; s = set_ordering (s, key, bl_end); if (*s) badfieldspec (argv[i]); } insertkey (key); key = NULL; goto outer; case 'm': mergeonly = 1; break; case 'o': if (s[1]) outfile = s + 1; else { if (i == argc - 1) error (2, 0, "option `-o' requires an argument"); else outfile = argv[++i]; } goto outer; case 's': stable = 1; break; case 't': if (s[1]) tab = *++s; else if (i < argc - 1) { tab = *argv[++i]; goto outer; } else error (2, 0, "option `-t' requires an argument"); break; case 'T': if (s[1]) temp_file_prefix = ++s; else { if (i < argc - 1) temp_file_prefix = argv[++i]; else error (2, 0, "option `-T' requires an argument"); } goto outer; break; case 'u': unique = 1; break; case 'y': /* Accept and ignore e.g. -y0 for compatibility with Solaris 2. */ goto outer; default: fprintf (stderr, "%s: unrecognized option `-%c'\n", argv[0], *s); usage (2); } if (*s) ++s; } } else /* Not an option. */ { files[nfiles++] = argv[i]; } outer:; } if (key) insertkey (key); /* Inheritance of global options to individual keys. */ for (key = keyhead.next; key; key = key->next) if (!key->ignore && !key->translate && !key->skipsblanks && !key->reverse && !key->skipeblanks && !key->month && !key->numeric) { key->ignore = gkey.ignore; key->translate = gkey.translate; key->skipsblanks = gkey.skipsblanks; key->skipeblanks = gkey.skipeblanks; key->month = gkey.month; key->numeric = gkey.numeric; key->reverse = gkey.reverse; } if (!keyhead.next && (gkey.ignore || gkey.translate || gkey.skipsblanks || gkey.skipeblanks || gkey.month || gkey.numeric)) insertkey (&gkey); reverse = gkey.reverse; if (nfiles == 0) { nfiles = 1; files = − } if (checkonly) exit (check (files, nfiles) != 0); if (strcmp (outfile, "-")) { struct stat outstat; if (stat (outfile, &outstat) == 0) { /* The following code prevents a race condition when people use the brain dead shell programming idiom: cat file | sort -o file This feature is provided for historical compatibility, but we strongly discourage ever relying on this in new shell programs. */ /* Temporarily copy each input file that might be another name for the output file. When in doubt (e.g. a pipe), copy. */ for (i = 0; i < nfiles; ++i) { char buf[8192]; FILE *fp; int cc; if (S_ISREG (outstat.st_mode) && strcmp (outfile, files[i])) { struct stat instat; if ((strcmp (files[i], "-") ? stat (files[i], &instat) : fstat (fileno (stdin), &instat)) != 0) { error (0, errno, "%s", files[i]); cleanup (); exit (2); } if (S_ISREG (instat.st_mode) && (instat.st_ino != outstat.st_ino || instat.st_dev != outstat.st_dev)) { /* We know the files are distinct. */ continue; } } fp = xfopen (files[i], "r"); tmp = tempname (); ofp = xfopen (tmp, "w"); while ((cc = fread (buf, 1, sizeof buf, fp)) > 0) xfwrite (buf, 1, cc, ofp); if (ferror (fp)) { error (0, errno, "%s", files[i]); cleanup (); exit (2); } xfclose (ofp); xfclose (fp); files[i] = tmp; } } ofp = xfopen (outfile, "w"); } else ofp = stdout; if (mergeonly) merge (files, nfiles, ofp); else sort (files, nfiles, ofp); cleanup (); /* If we wait for the implicit flush on exit, and the parent process has closed stdout (e.g., exec >&- in a shell), then the output file winds up empty. I don't understand why. This is under SunOS, Solaris, Ultrix, and Irix. This premature fflush makes the output reappear. --karl@cs.umb.edu */ if (fflush (ofp) < 0) error (1, errno, "%s: write error", outfile); if (have_read_stdin && fclose (stdin) == EOF) error (1, errno, outfile); if (ferror (stdout) || fclose (stdout) == EOF) error (1, errno, "%s: write error", outfile); exit (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 ("\ Write sorted concatenation of all FILE(s) to standard output.\n\ \n\ +POS1 [-POS2] start a key at POS1, end it before POS2\n\ -M compare (unknown) < `JAN' < ... < `DEC', imply -b\n\ -T DIRECT use DIRECT for temporary files, not $TMPDIR or %s\n\ -b ignore leading blanks in sort fields or keys\n\ -c check if given files already sorted, do not sort\n\ -d consider only [a-zA-Z0-9 ] characters in keys\n\ -f fold lower case to upper case characters in keys\n\ -i consider only [\\040-\\0176] characters in keys\n\ -k POS1[,POS2] same as +POS1 [-POS2], but all positions counted from 1\n\ -m merge already sorted files, do not sort\n\ -n compare according to string numerical value, imply -b\n\ -o FILE write result on FILE instead of standard output\n\ -r reverse the result of comparisons\n\ -s stabilize sort by disabling last resort comparison\n\ -t SEP use SEParator instead of non- to whitespace transition\n\ -u with -c, check for strict ordering\n\ -u with -m, only output the first of an equal sequence\n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ POS is F[.C][OPTS], where F is the field number and C the character\n\ position in the field, both counted from zero. OPTS is made up of one\n\ or more of Mbdfinr, this effectively disable global -Mbdfinr settings\n\ for that key. If no key given, use the entire line as key. With no\n\ FILE, or when FILE is -, read standard input.\n\ " , DEFAULT_TMPDIR); } exit (status); } textutils-1.12/src/split.c100666 74504 13 31525 5770310635 14706 0ustar meyeringuser/* split.c -- split a file into pieces. Copyright (C) 1988, 1991, 1995 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* By tege@sics.se, with rms. To do: * Implement -t CHAR or -t REGEX to specify break characters other than newline. */ #include #include #include #include #include "system.h" #include "version.h" #include "error.h" char *xmalloc (); int full_write (); int safe_read (); static int convint (); static int isdigits (); static int stdread (); static void line_bytes_split (); static void bytes_split (); static void cwrite (); static void lines_split (); static void next_file_name (); /* The name this program was run with. */ char *program_name; /* Base name of output files. */ static char *outfile; /* Pointer to the end of the prefix in OUTFILE. Suffixes are inserted here. */ static char *outfile_mid; /* Pointer to the end of OUTFILE. */ static char *outfile_end; /* Name of input file. May be "-". */ static char *infile; /* Descriptor on which input file is open. */ static int input_desc; /* Descriptor on which output file is open. */ static int output_desc; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output then exit. */ static int show_version; static struct option const longopts[] = { {"bytes", required_argument, NULL, 'b'}, {"lines", required_argument, NULL, 'l'}, {"line-bytes", required_argument, NULL, 'C'}, {"help", no_argument, &show_help, 1}, {"version", no_argument, &show_version, 1}, {NULL, 0, NULL, 0} }; static void usage (status, reason) int status; char *reason; { if (reason != NULL) fprintf (stderr, "%s: %s\n", program_name, reason); if (status != 0) fprintf (stderr, "Try `%s --help' for more information.\n", program_name); else { printf ("\ Usage: %s [OPTION] [INPUT [PREFIX]]\n\ ", program_name); printf ("\ Output fixed-size pieces of INPUT to PREFIXaa, PREFIXab, ...; default\n\ PREFIX is `x'. With no INPUT, or when INPUT is -, read standard input.\n\ \n\ -C, --line-bytes=SIZE put at most SIZE bytes of lines per output file\n\ -b, --bytes=SIZE put SIZE bytes per output file\n\ -l, --lines=NUMBER put NUMBER lines per output file\n\ -NUMBER same as -l NUMBER\n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ SIZE may have a multiplier suffix: b for 512, k for 1K, m for 1 Meg.\n\ "); } exit (status); } void main (argc, argv) int argc; char *argv[]; { struct stat stat_buf; int num; /* numeric argument from command line */ enum { type_undef, type_bytes, type_byteslines, type_lines, type_digits } split_type = type_undef; int in_blk_size; /* optimal block size of input file device */ char *buf; /* file i/o buffer */ int accum = 0; char *outbase; int c; int digits_optind = 0; program_name = argv[0]; /* Parse command line options. */ infile = "-"; outbase = "x"; while (1) { /* This is the argv-index of the option we will read next. */ int this_optind = optind ? optind : 1; c = getopt_long (argc, argv, "0123456789b:l:C:", longopts, (int *) 0); if (c == EOF) break; switch (c) { case 0: break; case 'b': if (split_type != type_undef) usage (2, "cannot split in more than one way"); split_type = type_bytes; if (convint (optarg, &accum) == -1) usage (2, "invalid number of bytes"); break; case 'l': if (split_type != type_undef) usage (2, "cannot split in more than one way"); split_type = type_lines; if (!isdigits (optarg)) usage (2, "invalid number of lines"); accum = atoi (optarg); break; case 'C': if (split_type != type_undef) usage (2, "cannot split in more than one way"); split_type = type_byteslines; if (convint (optarg, &accum) == -1) usage (2, "invalid number of bytes"); break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': if (split_type != type_undef && split_type != type_digits) usage (2, "cannot split in more than one way"); if (digits_optind != 0 && digits_optind != this_optind) accum = 0; /* More than one number given; ignore other. */ digits_optind = this_optind; split_type = type_digits; accum = accum * 10 + c - '0'; break; default: usage (2, (char *)0); } } if (show_version) { printf ("split - %s\n", version_string); exit (0); } if (show_help) usage (0, (char *)0); /* Handle default case. */ if (split_type == type_undef) { split_type = type_lines; accum = 1000; } if (accum < 1) usage (2, "invalid number"); num = accum; /* Get out the filename arguments. */ if (optind < argc) infile = argv[optind++]; if (optind < argc) outbase = argv[optind++]; if (optind < argc) usage (2, "too many arguments"); /* Open the input file. */ if (!strcmp (infile, "-")) input_desc = 0; else { input_desc = open (infile, O_RDONLY); if (input_desc < 0) error (1, errno, "%s", infile); } /* No output file is open now. */ output_desc = -1; /* Copy the output file prefix so we can add suffixes to it. 26**29 is certainly enough output files! */ outfile = xmalloc (strlen (outbase) + 30); strcpy (outfile, outbase); outfile_mid = outfile + strlen (outfile); outfile_end = outfile_mid + 2; memset (outfile_mid, 0, 30); outfile_mid[0] = 'a'; outfile_mid[1] = 'a' - 1; /* first call to next_file_name makes it an 'a' */ /* Get the optimal block size of input device and make a buffer. */ if (fstat (input_desc, &stat_buf) < 0) error (1, errno, "%s", infile); in_blk_size = ST_BLKSIZE (stat_buf); buf = xmalloc (in_blk_size + 1); switch (split_type) { case type_digits: case type_lines: lines_split (num, buf, in_blk_size); break; case type_bytes: bytes_split (num, buf, in_blk_size); break; case type_byteslines: line_bytes_split (num); break; default: abort (); } if (close (input_desc) < 0) error (1, errno, "%s", infile); if (output_desc >= 0 && close (output_desc) < 0) error (1, errno, "%s", outfile); exit (0); } /* Return nonzero if the string STR is composed entirely of decimal digits. */ static int isdigits (str) char *str; { do { if (!ISDIGIT (*str)) return 0; str++; } while (*str); return 1; } /* Put the value of the number in STR into *VAL. STR can specify a positive integer, optionally ending in `k' to mean kilo or `m' to mean mega. Return 0 if STR is valid, -1 if not. */ static int convint (str, val) char *str; int *val; { int multiplier = 1; int arglen = strlen (str); if (arglen > 1) { switch (str[arglen - 1]) { case 'b': multiplier = 512; str[arglen - 1] = '\0'; break; case 'k': multiplier = 1024; str[arglen - 1] = '\0'; break; case 'm': multiplier = 1048576; str[arglen - 1] = '\0'; break; } } if (!isdigits (str)) return -1; *val = atoi (str) * multiplier; return 0; } /* Split into pieces of exactly NCHARS bytes. Use buffer BUF, whose size is BUFSIZE. */ static void bytes_split (nchars, buf, bufsize) int nchars; char *buf; int bufsize; { int n_read; int new_file_flag = 1; int to_read; int to_write = nchars; char *bp_out; do { n_read = stdread (buf, bufsize); if (n_read < 0) error (1, errno, "%s", infile); bp_out = buf; to_read = n_read; for (;;) { if (to_read < to_write) { if (to_read) /* do not write 0 bytes! */ { cwrite (new_file_flag, bp_out, to_read); to_write -= to_read; new_file_flag = 0; } break; } else { cwrite (new_file_flag, bp_out, to_write); bp_out += to_write; to_read -= to_write; new_file_flag = 1; to_write = nchars; } } } while (n_read == bufsize); } /* Split into pieces of exactly NLINES lines. Use buffer BUF, whose size is BUFSIZE. */ static void lines_split (nlines, buf, bufsize) int nlines; char *buf; int bufsize; { int n_read; char *bp, *bp_out, *eob; int new_file_flag = 1; int n = 0; do { n_read = stdread (buf, bufsize); if (n_read < 0) error (1, errno, "%s", infile); bp = bp_out = buf; eob = bp + n_read; *eob = '\n'; for (;;) { while (*bp++ != '\n') ; /* this semicolon takes most of the time */ if (bp > eob) { if (eob != bp_out) /* do not write 0 bytes! */ { cwrite (new_file_flag, bp_out, eob - bp_out); new_file_flag = 0; } break; } else if (++n >= nlines) { cwrite (new_file_flag, bp_out, bp - bp_out); bp_out = bp; new_file_flag = 1; n = 0; } } } while (n_read == bufsize); } /* Split into pieces that are as large as possible while still not more than NCHARS bytes, and are split on line boundaries except where lines longer than NCHARS bytes occur. */ static void line_bytes_split (nchars) int nchars; { int n_read; char *bp; int eof = 0; int n_buffered = 0; char *buf = (char *) xmalloc (nchars); do { /* Fill up the full buffer size from the input file. */ n_read = stdread (buf + n_buffered, nchars - n_buffered); if (n_read < 0) error (1, errno, "%s", infile); n_buffered += n_read; if (n_buffered != nchars) eof = 1; /* Find where to end this chunk. */ bp = buf + n_buffered; if (n_buffered == nchars) { while (bp > buf && bp[-1] != '\n') bp--; } /* If chunk has no newlines, use all the chunk. */ if (bp == buf) bp = buf + n_buffered; /* Output the chars as one output file. */ cwrite (1, buf, bp - buf); /* Discard the chars we just output; move rest of chunk down to be the start of the next chunk. Source and destination probably overlap. */ n_buffered -= bp - buf; if (n_buffered > 0) memmove (buf, bp, n_buffered); } while (!eof); free (buf); } /* Write BYTES bytes at BP to an output file. If NEW_FILE_FLAG is nonzero, open the next output file. Otherwise add to the same output file already in use. */ static void cwrite (new_file_flag, bp, bytes) int new_file_flag; char *bp; int bytes; { if (new_file_flag) { if (output_desc >= 0 && close (output_desc) < 0) error (1, errno, "%s", outfile); next_file_name (); output_desc = open (outfile, O_WRONLY | O_CREAT | O_TRUNC, 0666); if (output_desc < 0) error (1, errno, "%s", outfile); } if (full_write (output_desc, bp, bytes) < 0) error (1, errno, "%s", outfile); } /* Read NCHARS bytes from the input file into BUF. Return the number of bytes successfully read. If this is less than NCHARS, do not call `stdread' again. */ static int stdread (buf, nchars) char *buf; int nchars; { int n_read; int to_be_read = nchars; while (to_be_read) { n_read = safe_read (input_desc, buf, to_be_read); if (n_read < 0) return -1; if (n_read == 0) break; to_be_read -= n_read; buf += n_read; } return nchars - to_be_read; } /* Compute the next sequential output file name suffix and store it into the string `outfile' at the position pointed to by `outfile_mid'. */ static void next_file_name () { int x; char *ne; unsigned int i; static int first_call = 1; /* Status for outfile name generation. */ static unsigned outfile_count = 0; static unsigned outfile_name_limit = 25 * 26; static unsigned outfile_name_generation = 1; if (!first_call) outfile_count++; first_call = 0; if (outfile_count < outfile_name_limit) { for (ne = outfile_end - 1; ; ne--) { x = *ne; if (x != 'z') break; *ne = 'a'; } *ne = x + 1; return; } outfile_count = 0; outfile_name_limit *= 26; outfile_name_generation++; *outfile_mid++ = 'z'; for (i = 0; i <= outfile_name_generation; i++) outfile_mid[i] = 'a'; outfile_end += 2; } textutils-1.12/src/sum.c100666 74504 13 13765 5770310641 14362 0ustar meyeringuser/* sum -- checksum and count the blocks in a file Copyright (C) 1986, 1989, 1991, 1995 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* Like BSD sum or SysV sum -r, except like SysV sum if -s option is given. */ /* Written by Kayvan Aghaiepour and David MacKenzie. */ #include #include #include #include #include "system.h" #include "version.h" #include "error.h" static int bsd_sum_file (); static int sysv_sum_file (); int safe_read (); /* The name this program was run with. */ char *program_name; /* Nonzero if any of the files read were the standard input. */ static int have_read_stdin; /* Right-rotate 32-bit integer variable C. */ #define ROTATE_RIGHT(c) if ((c) & 01) (c) = ((c) >>1) + 0x8000; else (c) >>= 1; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output then exit. */ static int show_version; static struct option const longopts[] = { {"sysv", no_argument, NULL, 's'}, {"help", no_argument, &show_help, 1}, {"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 ("\ Print checksum and block counts for each FILE.\n\ \n\ -r defeat -s, use BSD sum algorithm, use 1K blocks\n\ -s, --sysv use System V sum algorithm, use 512 bytes blocks\n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ With no FILE, or when FILE is -, read standard input.\n\ "); } exit (status); } void main (argc, argv) int argc; char **argv; { int errors = 0; int optc; int files_given; int (*sum_func) () = bsd_sum_file; program_name = argv[0]; have_read_stdin = 0; while ((optc = getopt_long (argc, argv, "rs", longopts, (int *) 0)) != -1) { switch (optc) { case 0: break; case 'r': /* For SysV compatibility. */ sum_func = bsd_sum_file; break; case 's': sum_func = sysv_sum_file; break; default: usage (1); } } if (show_version) { printf ("sum - %s\n", version_string); exit (0); } if (show_help) usage (0); files_given = argc - optind; if (files_given == 0) { if ((*sum_func) ("-", files_given) < 0) errors = 1; } else for (; optind < argc; optind++) if ((*sum_func) (argv[optind], files_given) < 0) errors = 1; if (have_read_stdin && fclose (stdin) == EOF) error (1, errno, "-"); exit (errors); } /* Calculate and print the rotated checksum and the size in 1K blocks of file FILE, or of the standard input if FILE is "-". If PRINT_NAME is >1, print FILE next to the checksum and size. The checksum varies depending on sizeof(int). Return 0 if successful, -1 if an error occurs. */ static int bsd_sum_file (file, print_name) char *file; int print_name; { register FILE *fp; register unsigned long checksum = 0; /* The checksum mod 2^16. */ register long total_bytes = 0; /* The number of bytes. */ register int ch; /* Each character read. */ if (!strcmp (file, "-")) { fp = stdin; have_read_stdin = 1; } else { fp = fopen (file, "r"); if (fp == NULL) { error (0, errno, "%s", file); return -1; } } /* This algorithm seems to depend on sign extension in `ch' in order to give the right results. Ick. */ while ((ch = getc (fp)) != EOF) { total_bytes++; ROTATE_RIGHT (checksum); checksum += ch; checksum &= 0xffff; /* Keep it within bounds. */ } if (ferror (fp)) { error (0, errno, "%s", file); if (strcmp (file, "-")) fclose (fp); return -1; } if (strcmp (file, "-") && fclose (fp) == EOF) { error (0, errno, "%s", file); return -1; } printf ("%05lu %5ld", checksum, (total_bytes + 1024 - 1) / 1024); if (print_name > 1) printf (" %s", file); putchar ('\n'); return 0; } /* Calculate and print the checksum and the size in 512-byte blocks of file FILE, or of the standard input if FILE is "-". If PRINT_NAME is >0, print FILE next to the checksum and size. Return 0 if successful, -1 if an error occurs. */ static int sysv_sum_file (file, print_name) char *file; int print_name; { int fd; unsigned char buf[8192]; register int bytes_read; register unsigned long checksum = 0; long total_bytes = 0; if (!strcmp (file, "-")) { fd = 0; have_read_stdin = 1; } else { fd = open (file, O_RDONLY); if (fd == -1) { error (0, errno, "%s", file); return -1; } } while ((bytes_read = safe_read (fd, buf, sizeof buf)) > 0) { register int i; for (i = 0; i < bytes_read; i++) checksum += buf[i]; total_bytes += bytes_read; } if (bytes_read < 0) { error (0, errno, "%s", file); if (strcmp (file, "-")) close (fd); return -1; } if (strcmp (file, "-") && close (fd) == -1) { error (0, errno, "%s", file); return -1; } printf ("%lu %ld", checksum % 0xffff, (total_bytes + 512 - 1) / 512); if (print_name) printf (" %s", file); putchar ('\n'); return 0; } textutils-1.12/src/tac.c100666 74504 13 42663 5770310646 14331 0ustar meyeringuser/* tac - concatenate and print files in reverse Copyright (C) 1988, 1989, 1990, 1991, 1995 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* Written by Jay Lepreau (lepreau@cs.utah.edu). GNU enhancements by David MacKenzie (djm@gnu.ai.mit.edu). */ /* Copy each FILE, or the standard input if none are given or when a FILE name of "-" is encountered, to the standard output with the order of the records reversed. The records are separated by instances of a string, or a newline if none is given. By default, the separator string is attached to the end of the record that it follows in the file. Options: -b, --before The separator is attached to the beginning of the record that it precedes in the file. -r, --regex The separator is a regular expression. -s, --separator=separator Use SEPARATOR as the record separator. To reverse a file byte by byte, use (in bash, ksh, or sh): tac -r -s '.\| ' file */ #include #include #include #include #include #include #include "system.h" #include "version.h" #include "error.h" #ifndef STDC_HEADERS char *malloc (); char *realloc (); #endif #ifndef DEFAULT_TMPDIR #define DEFAULT_TMPDIR "/tmp" #endif /* The number of bytes per atomic read. */ #define INITIAL_READSIZE 8192 /* The number of bytes per atomic write. */ #define WRITESIZE 8192 char *mktemp (); static RETSIGTYPE cleanup (); static int tac (); static int tac_file (); static int tac_stdin (); static char *xmalloc (); static char *xrealloc (); static void output (); static void save_stdin (); static void xwrite (); int full_write (); int safe_read (); /* The name this program was run with. */ char *program_name; /* The string that separates the records of the file. */ static char *separator; /* If nonzero, print `separator' along with the record preceding it in the file; otherwise with the record following it. */ static int separator_ends_record; /* 0 if `separator' is to be matched as a regular expression; otherwise, the length of `separator', used as a sentinel to stop the search. */ static int sentinel_length; /* The length of a match with `separator'. If `sentinel_length' is 0, `match_length' is computed every time a match succeeds; otherwise, it is simply the length of `separator'. */ static int match_length; /* The input buffer. */ static char *buffer; /* The number of bytes to read at once into `buffer'. */ static unsigned read_size; /* The size of `buffer'. This is read_size * 2 + sentinel_length + 2. The extra 2 bytes allow `past_end' to have a value beyond the end of `buffer' and `match_start' to run off the front of `buffer'. */ static unsigned buffer_size; /* The compiled regular expression representing `separator'. */ static struct re_pattern_buffer compiled_separator; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output then exit. */ static int show_version; static struct option const longopts[] = { {"before", no_argument, &separator_ends_record, 0}, {"regex", no_argument, &sentinel_length, 0}, {"separator", required_argument, NULL, 's'}, {"help", no_argument, &show_help, 1}, {"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 ("\ Write each FILE to standard output, last line first.\n\ With no FILE, or when FILE is -, read standard input.\n\ \n\ -b, --before attach the separator before instead of after\n\ -r, --regex interpret the separator as a regular expression\n\ -s, --separator=STRING use STRING as the separator instead of newline\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; { const char *error_message; /* Return value from re_compile_pattern. */ int optc, errors; int have_read_stdin = 0; program_name = argv[0]; errors = 0; separator = "\n"; sentinel_length = 1; separator_ends_record = 1; while ((optc = getopt_long (argc, argv, "brs:", longopts, (int *) 0)) != EOF) { switch (optc) { case 0: break; case 'b': separator_ends_record = 0; break; case 'r': sentinel_length = 0; break; case 's': separator = optarg; if (*separator == 0) error (1, 0, "separator cannot be empty"); break; default: usage (1); } } if (show_version) { printf ("tac - %s\n", version_string); exit (0); } if (show_help) usage (0); if (sentinel_length == 0) { compiled_separator.allocated = 100; compiled_separator.buffer = (unsigned char *) xmalloc (compiled_separator.allocated); compiled_separator.fastmap = xmalloc (256); compiled_separator.translate = 0; error_message = re_compile_pattern (separator, strlen (separator), &compiled_separator); if (error_message) error (1, 0, "%s", error_message); } else match_length = sentinel_length = strlen (separator); read_size = INITIAL_READSIZE; /* A precaution that will probably never be needed. */ while (sentinel_length * 2 >= read_size) read_size *= 2; buffer_size = read_size * 2 + sentinel_length + 2; buffer = xmalloc (buffer_size); if (sentinel_length) { strcpy (buffer, separator); buffer += sentinel_length; } else ++buffer; if (optind == argc) { have_read_stdin = 1; errors = tac_stdin (); } else for (; optind < argc; ++optind) { if (strcmp (argv[optind], "-") == 0) { have_read_stdin = 1; errors |= tac_stdin (); } else errors |= tac_file (argv[optind]); } /* Flush the output buffer. */ output ((char *) NULL, (char *) NULL); if (have_read_stdin && close (0) < 0) error (1, errno, "-"); if (close (1) < 0) error (1, errno, "write error"); exit (errors); } /* The name of a temporary file containing a copy of pipe input. */ char *tempfile; /* Print the standard input in reverse, saving it to temporary file `tempfile' first if it is a pipe. Return 0 if ok, 1 if an error occurs. */ static int tac_stdin () { /* Previous values of signal handlers. */ RETSIGTYPE (*sigint) (), (*sighup) (), (*sigpipe) (), (*sigterm) (); int errors; struct stat stats; #ifdef _POSIX_VERSION struct sigaction oldact, newact; #endif /* _POSIX_VERSION */ /* No tempfile is needed for "tac < file". Use fstat instead of checking for errno == ESPIPE because lseek doesn't work on some special files but doesn't return an error, either. */ if (fstat (0, &stats)) { error (0, errno, "standard input"); return 1; } if (S_ISREG (stats.st_mode)) return tac (0, "standard input"); #ifdef _POSIX_VERSION newact.sa_handler = cleanup; sigemptyset (&newact.sa_mask); newact.sa_flags = 0; sigaction (SIGINT, NULL, &oldact); sigint = oldact.sa_handler; if (sigint != SIG_IGN) sigaction (SIGINT, &newact, NULL); sigaction (SIGHUP, NULL, &oldact); sighup = oldact.sa_handler; if (sighup != SIG_IGN) sigaction (SIGHUP, &newact, NULL); sigaction (SIGPIPE, NULL, &oldact); sigpipe = oldact.sa_handler; if (sigpipe != SIG_IGN) sigaction (SIGPIPE, &newact, NULL); sigaction (SIGTERM, NULL, &oldact); sigterm = oldact.sa_handler; if (sigterm != SIG_IGN) sigaction (SIGTERM, &newact, NULL); #else /* !_POSIX_VERSION */ sigint = signal (SIGINT, SIG_IGN); if (sigint != SIG_IGN) signal (SIGINT, cleanup); sighup = signal (SIGHUP, SIG_IGN); if (sighup != SIG_IGN) signal (SIGHUP, cleanup); sigpipe = signal (SIGPIPE, SIG_IGN); if (sigpipe != SIG_IGN) signal (SIGPIPE, cleanup); sigterm = signal (SIGTERM, SIG_IGN); if (sigterm != SIG_IGN) signal (SIGTERM, cleanup); #endif /* _POSIX_VERSION */ save_stdin (); errors = tac_file (tempfile); unlink (tempfile); #ifdef _POSIX_VERSION newact.sa_handler = sigint; sigaction (SIGINT, &newact, NULL); newact.sa_handler = sighup; sigaction (SIGHUP, &newact, NULL); newact.sa_handler = sigterm; sigaction (SIGTERM, &newact, NULL); newact.sa_handler = sigpipe; sigaction (SIGPIPE, &newact, NULL); #else /* !_POSIX_VERSION */ signal (SIGINT, sigint); signal (SIGHUP, sighup); signal (SIGTERM, sigterm); signal (SIGPIPE, sigpipe); #endif /* _POSIX_VERSION */ return errors; } /* Make a copy of the standard input in `tempfile'. */ static void save_stdin () { static char *template = NULL; static char *tempdir; int fd; int bytes_read; if (template == NULL) { tempdir = getenv ("TMPDIR"); if (tempdir == NULL) tempdir = DEFAULT_TMPDIR; template = xmalloc (strlen (tempdir) + 11); } sprintf (template, "%s/tacXXXXXX", tempdir); tempfile = mktemp (template); fd = creat (tempfile, 0600); if (fd == -1) { error (0, errno, "%s", tempfile); cleanup (); } while ((bytes_read = safe_read (0, buffer, read_size)) > 0) if (full_write (fd, buffer, bytes_read) < 0) { error (0, errno, "%s", tempfile); cleanup (); } if (close (fd) < 0) { error (0, errno, "%s", tempfile); cleanup (); } if (bytes_read == -1) { error (0, errno, "read error"); cleanup (); } } /* Print FILE in reverse. Return 0 if ok, 1 if an error occurs. */ static int tac_file (file) char *file; { int fd, errors; fd = open (file, O_RDONLY); if (fd == -1) { error (0, errno, "%s", file); return 1; } errors = tac (fd, file); if (close (fd) < 0) { error (0, errno, "%s", file); return 1; } return errors; } /* Print in reverse the file open on descriptor FD for reading FILE. Return 0 if ok, 1 if an error occurs. */ static int tac (fd, file) int fd; char *file; { /* Pointer to the location in `buffer' where the search for the next separator will begin. */ char *match_start; /* Pointer to one past the rightmost character in `buffer' that has not been printed yet. */ char *past_end; unsigned saved_record_size; /* Length of the record growing in `buffer'. */ off_t file_pos; /* Offset in the file of the next read. */ /* Nonzero if `output' has not been called yet for any file. Only used when the separator is attached to the preceding record. */ int first_time = 1; char first_char = *separator; /* Speed optimization, non-regexp. */ char *separator1 = separator + 1; /* Speed optimization, non-regexp. */ int match_length1 = match_length - 1; /* Speed optimization, non-regexp. */ struct re_registers regs; /* Find the size of the input file. */ file_pos = lseek (fd, (off_t) 0, SEEK_END); if (file_pos < 1) return 0; /* It's an empty file. */ /* Arrange for the first read to lop off enough to leave the rest of the file a multiple of `read_size'. Since `read_size' can change, this may not always hold during the program run, but since it usually will, leave it here for i/o efficiency (page/sector boundaries and all that). Note: the efficiency gain has not been verified. */ saved_record_size = file_pos % read_size; if (saved_record_size == 0) saved_record_size = read_size; file_pos -= saved_record_size; /* `file_pos' now points to the start of the last (probably partial) block in the input file. */ lseek (fd, file_pos, SEEK_SET); if (safe_read (fd, buffer, saved_record_size) != saved_record_size) { error (0, errno, "%s", file); return 1; } match_start = past_end = buffer + saved_record_size; /* For non-regexp search, move past impossible positions for a match. */ if (sentinel_length) match_start -= match_length1; for (;;) { /* Search backward from `match_start' - 1 to `buffer' for a match with `separator'; for speed, use strncmp if `separator' contains no metacharacters. If the match succeeds, set `match_start' to point to the start of the match and `match_length' to the length of the match. Otherwise, make `match_start' < `buffer'. */ if (sentinel_length == 0) { int i = match_start - buffer; int ret; ret = re_search (&compiled_separator, buffer, i, i - 1, -i, ®s); if (ret == -1) match_start = buffer - 1; else if (ret == -2) { error (0, 0, "error in regular expression search"); cleanup (); } else { match_start = buffer + regs.start[0]; match_length = regs.end[0] - regs.start[0]; } } else { /* `match_length' is constant for non-regexp boundaries. */ while (*--match_start != first_char || (match_length1 && strncmp (match_start + 1, separator1, match_length1))) /* Do nothing. */ ; } /* Check whether we backed off the front of `buffer' without finding a match for `separator'. */ if (match_start < buffer) { if (file_pos == 0) { /* Hit the beginning of the file; print the remaining record. */ output (buffer, past_end); return 0; } saved_record_size = past_end - buffer; if (saved_record_size > read_size) { /* `buffer_size' is about twice `read_size', so since we want to read in another `read_size' bytes before the data already in `buffer', we need to increase `buffer_size'. */ char *newbuffer; int offset = sentinel_length ? sentinel_length : 1; read_size *= 2; buffer_size = read_size * 2 + sentinel_length + 2; newbuffer = xrealloc (buffer - offset, buffer_size) + offset; /* Adjust the pointers for the new buffer location. */ match_start += newbuffer - buffer; past_end += newbuffer - buffer; buffer = newbuffer; } /* Back up to the start of the next bufferfull of the file. */ if (file_pos >= read_size) file_pos -= read_size; else { read_size = file_pos; file_pos = 0; } lseek (fd, file_pos, SEEK_SET); /* Shift the pending record data right to make room for the new. The source and destination regions probably overlap. */ memmove (buffer + read_size, buffer, saved_record_size); past_end = buffer + read_size + saved_record_size; /* For non-regexp searches, avoid unneccessary scanning. */ if (sentinel_length) match_start = buffer + read_size; else match_start = past_end; if (safe_read (fd, buffer, read_size) != read_size) { error (0, errno, "%s", file); return 1; } } else { /* Found a match of `separator'. */ if (separator_ends_record) { char *match_end = match_start + match_length; /* If this match of `separator' isn't at the end of the file, print the record. */ if (first_time == 0 || match_end != past_end) output (match_end, past_end); past_end = match_end; first_time = 0; } else { output (match_start, past_end); past_end = match_start; } match_start -= match_length - 1; } } } /* Print the characters from START to PAST_END - 1. If START is NULL, just flush the buffer. */ static void output (start, past_end) char *start; char *past_end; { static char buffer[WRITESIZE]; static int bytes_in_buffer = 0; int bytes_to_add = past_end - start; int bytes_available = WRITESIZE - bytes_in_buffer; if (start == 0) { xwrite (STDOUT_FILENO, buffer, bytes_in_buffer); bytes_in_buffer = 0; return; } /* Write out as many full buffers as possible. */ while (bytes_to_add >= bytes_available) { memcpy (buffer + bytes_in_buffer, start, bytes_available); bytes_to_add -= bytes_available; start += bytes_available; xwrite (STDOUT_FILENO, buffer, WRITESIZE); bytes_in_buffer = 0; bytes_available = WRITESIZE; } memcpy (buffer + bytes_in_buffer, start, bytes_to_add); bytes_in_buffer += bytes_to_add; } static RETSIGTYPE cleanup () { unlink (tempfile); exit (1); } static void xwrite (desc, buffer, size) int desc; char *buffer; int size; { if (full_write (desc, buffer, size) < 0) { error (0, errno, "write error"); cleanup (); } } /* Allocate N bytes of memory dynamically, with error checking. */ static char * xmalloc (n) unsigned n; { char *p; p = malloc (n); if (p == 0) { error (0, 0, "virtual memory exhausted"); cleanup (); } return p; } /* Change the size of memory area P to N bytes, with error checking. */ static char * xrealloc (p, n) char *p; unsigned n; { p = realloc (p, n); if (p == 0) { error (0, 0, "virtual memory exhausted"); cleanup (); } return p; } textutils-1.12/src/tail.c100666 74504 13 63062 5770310652 14504 0ustar meyeringuser/* tail -- output the last part of file(s) Copyright (C) 1989, 1990, 1991, 1995 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* Can display any amount of data, unlike the Unix version, which uses a fixed size buffer and therefore can only deliver a limited number of lines. Options: -b Tail by N 512-byte blocks. -c, --bytes=N[bkm] Tail by N bytes [or 512-byte blocks, kilobytes, or megabytes]. -f, --follow Loop forever trying to read more characters at the end of the file, on the assumption that the file is growing. Ignored if reading from a pipe. -n, --lines=N Tail by N lines. -q, --quiet, --silent Never print filename headers. -v, --verbose Always print filename headers. If a number (N) starts with a `+', begin printing with the Nth item from the start of each file, instead of from the end. Reads from standard input if no files are given or when a filename of ``-'' is encountered. By default, filename headers are printed only more than one file is given. By default, prints the last 10 lines (tail -n 10). Original version by Paul Rubin . Extensions by David MacKenzie . tail -f for multiple files by Ian Lance Taylor . */ #include #include #include #include #include #include "system.h" #include "version.h" #include "xstrtol.h" #include "error.h" /* Disable assertions. Some systems have broken assert macros. */ #define NDEBUG 1 #define XWRITE(fd, buffer, n_bytes) \ do \ { \ assert ((fd) == 1); \ assert ((n_bytes) >= 0); \ if (n_bytes > 0 && fwrite ((buffer), 1, (n_bytes), stdout) == 0) \ error (1, errno, "write error"); \ } \ while (0) /* Number of items to tail. */ #define DEFAULT_N_LINES 10 /* Size of atomic reads. */ #ifndef BUFSIZ #define BUFSIZ (512 * 8) #endif /* If nonzero, interpret the numeric argument as the number of lines. Otherwise, interpret it as the number of bytes. */ static int count_lines; /* If nonzero, read from the end of one file until killed. */ static int forever; /* If nonzero, read from the end of multiple files until killed. */ static int forever_multiple; /* Array of file descriptors if forever_multiple is 1. */ static int *file_descs; /* Array of file sizes if forever_multiple is 1. */ static off_t *file_sizes; /* If nonzero, count from start of file instead of end. */ static int from_start; /* If nonzero, print filename headers. */ static int print_headers; /* When to print the filename banners. */ enum header_mode { multiple_files, always, never }; char *xmalloc (); int safe_read (); static int file_lines (); static int pipe_bytes (); static int pipe_lines (); static int start_bytes (); static int start_lines (); static int tail (); static int tail_bytes (); static int tail_file (); static int tail_lines (); static long dump_remainder (); static void tail_forever (); static void usage (); static void write_header (); /* The name this program was run with. */ char *program_name; /* Nonzero if we have ever read standard input. */ static int have_read_stdin; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output then exit. */ static int show_version; static struct option const long_options[] = { {"bytes", required_argument, NULL, 'c'}, {"follow", no_argument, NULL, 'f'}, {"lines", required_argument, NULL, 'n'}, {"quiet", no_argument, NULL, 'q'}, {"silent", no_argument, NULL, 'q'}, {"verbose", no_argument, NULL, 'v'}, {"help", no_argument, &show_help, 1}, {"version", no_argument, &show_version, 1}, {NULL, 0, NULL, 0} }; void main (argc, argv) int argc; char **argv; { enum header_mode header_mode = multiple_files; int exit_status = 0; /* If from_start, the number of items to skip before printing; otherwise, the number of items at the end of the file to print. Initially, -1 means the value has not been set. */ off_t n_units = -1; long int tmp_long; int c; /* Option character. */ int fileind; /* Index in ARGV of first file name. */ program_name = argv[0]; have_read_stdin = 0; count_lines = 1; forever = forever_multiple = from_start = print_headers = 0; if (argc > 1 && ((argv[1][0] == '-' && ISDIGIT (argv[1][1])) || (argv[1][0] == '+' && (ISDIGIT (argv[1][1]) || argv[1][1] == 0)))) { /* Old option syntax: a dash or plus, one or more digits (zero digits are acceptable with a plus), and one or more option letters. */ if (argv[1][0] == '+') from_start = 1; if (argv[1][1] != '\0') { strtol_error s_err; char *p; s_err = xstrtol (++argv[1], &p, 0, &tmp_long, "bkm"); n_units = tmp_long; if (s_err == LONGINT_OVERFLOW) { STRTOL_FATAL_ERROR (argv[1], "argument", s_err); } /* Parse any appended option letters. */ while (*p) { switch (*p) { case 'c': /* Interpret N_UNITS as # of bytes. */ count_lines = 0; break; case 'f': forever = 1; break; case 'l': count_lines = 1; break; case 'q': header_mode = never; break; case 'v': header_mode = always; break; default: error (0, 0, "unrecognized option `-%c'", *p); usage (1); } ++p; } } /* Make the options we just parsed invisible to getopt. */ argv[1] = argv[0]; argv++; argc--; } while ((c = getopt_long (argc, argv, "c:n:fqv", long_options, (int *) 0)) != EOF) { strtol_error s_err; switch (c) { case 0: break; case 'c': count_lines = 0; goto getnum; case 'n': count_lines = 1; getnum: if (*optarg == '+') { from_start = 1; } s_err = xstrtol (optarg, NULL, 0, &tmp_long, "bkm"); if (tmp_long < 0) tmp_long = -tmp_long; n_units = tmp_long; if (s_err != LONGINT_OK) { STRTOL_FATAL_ERROR (optarg, (c == 'n' ? "number of lines" : "number of bytes"), s_err); } break; case 'f': forever = 1; break; case 'q': header_mode = never; break; case 'v': header_mode = always; break; default: usage (1); } } if (show_version) { printf ("tail - %s\n", version_string); exit (0); } if (show_help) usage (0); if (n_units == -1) n_units = DEFAULT_N_LINES; /* To start printing with item N_UNITS from the start of the file, skip N_UNITS - 1 items. `tail +0' is actually meaningless, but for Unix compatibility it's treated the same as `tail +1'. */ if (from_start) { if (n_units) --n_units; } fileind = optind; if (optind < argc - 1 && forever) { forever_multiple = 1; forever = 0; file_descs = (int *) xmalloc ((argc - optind) * sizeof (int)); file_sizes = (off_t *) xmalloc ((argc - optind) * sizeof (off_t)); } if (header_mode == always || (header_mode == multiple_files && optind < argc - 1)) print_headers = 1; if (optind == argc) exit_status |= tail_file ("-", n_units, 0); for (; optind < argc; ++optind) exit_status |= tail_file (argv[optind], n_units, optind - fileind); if (forever_multiple) tail_forever (argv + fileind, argc - fileind); if (have_read_stdin && close (0) < 0) error (1, errno, "-"); if (fclose (stdout) == EOF) error (1, errno, "write error"); exit (exit_status); } /* Display the last N_UNITS units of file FILENAME. "-" for FILENAME means the standard input. FILENUM is this file's index in the list of files the user gave. Return 0 if successful, 1 if an error occurred. */ static int tail_file (filename, n_units, filenum) const char *filename; off_t n_units; int filenum; { int fd, errors; struct stat stats; if (!strcmp (filename, "-")) { have_read_stdin = 1; filename = "standard input"; if (print_headers) write_header (filename, NULL); errors = tail (filename, 0, n_units); if (forever_multiple) { if (fstat (0, &stats) < 0) { error (0, errno, "standard input"); errors = 1; } else if (!S_ISREG (stats.st_mode)) { error (0, 0, "standard input: cannot follow end of non-regular file"); errors = 1; } if (errors) file_descs[filenum] = -1; else { file_descs[filenum] = 0; file_sizes[filenum] = stats.st_size; } } } else { /* Not standard input. */ fd = open (filename, O_RDONLY); if (fd == -1) { if (forever_multiple) file_descs[filenum] = -1; error (0, errno, "%s", filename); errors = 1; } else { if (print_headers) write_header (filename, NULL); errors = tail (filename, fd, n_units); if (forever_multiple) { if (fstat (fd, &stats) < 0) { error (0, errno, "%s", filename); errors = 1; } else if (!S_ISREG (stats.st_mode)) { error (0, 0, "%s: cannot follow end of non-regular file", filename); errors = 1; } if (errors) { close (fd); file_descs[filenum] = -1; } else { file_descs[filenum] = fd; file_sizes[filenum] = stats.st_size; } } else { if (close (fd)) { error (0, errno, "%s", filename); errors = 1; } } } } return errors; } static void write_header (filename, comment) const char *filename; const char *comment; { static int first_file = 1; printf ("%s==> %s%s%s <==\n", (first_file ? "" : "\n"), filename, (comment ? ": " : ""), (comment ? comment : "")); first_file = 0; } /* Display the last N_UNITS units of file FILENAME, open for reading in FD. Return 0 if successful, 1 if an error occurred. */ static int tail (filename, fd, n_units) const char *filename; int fd; off_t n_units; { if (count_lines) return tail_lines (filename, fd, n_units); else return tail_bytes (filename, fd, n_units); } /* Output the last N_BYTES bytes of file FILENAME open for reading in FD. Return 0 if successful, 1 if an error occurred. */ static int tail_bytes (filename, fd, n_bytes) const char *filename; int fd; off_t n_bytes; { struct stat stats; /* FIXME: resolve this like in dd.c. */ /* Use fstat instead of checking for errno == ESPIPE because lseek doesn't work on some special files but doesn't return an error, either. */ if (fstat (fd, &stats)) { error (0, errno, "%s", filename); return 1; } if (from_start) { if (S_ISREG (stats.st_mode)) lseek (fd, n_bytes, SEEK_SET); else if (start_bytes (filename, fd, n_bytes)) return 1; dump_remainder (filename, fd); } else { if (S_ISREG (stats.st_mode)) { if (lseek (fd, (off_t) 0, SEEK_END) <= n_bytes) /* The file is shorter than we want, or just the right size, so print the whole file. */ lseek (fd, (off_t) 0, SEEK_SET); else /* The file is longer than we want, so go back. */ lseek (fd, -n_bytes, SEEK_END); dump_remainder (filename, fd); } else return pipe_bytes (filename, fd, n_bytes); } return 0; } /* Output the last N_LINES lines of file FILENAME open for reading in FD. Return 0 if successful, 1 if an error occurred. */ static int tail_lines (filename, fd, n_lines) const char *filename; int fd; long n_lines; { struct stat stats; off_t length; if (fstat (fd, &stats)) { error (0, errno, "%s", filename); return 1; } if (from_start) { if (start_lines (filename, fd, n_lines)) return 1; dump_remainder (filename, fd); } else { if (S_ISREG (stats.st_mode)) { length = lseek (fd, (off_t) 0, SEEK_END); if (length != 0 && file_lines (filename, fd, n_lines, length)) return 1; dump_remainder (filename, fd); } else return pipe_lines (filename, fd, n_lines); } return 0; } /* Print the last N_LINES lines from the end of file FD. Go backward through the file, reading `BUFSIZ' bytes at a time (except probably the first), until we hit the start of the file or have read NUMBER newlines. POS starts out as the length of the file (the offset of the last byte of the file + 1). Return 0 if successful, 1 if an error occurred. */ static int file_lines (filename, fd, n_lines, pos) const char *filename; int fd; long n_lines; off_t pos; { char buffer[BUFSIZ]; int bytes_read; int i; /* Index into `buffer' for scanning. */ if (n_lines == 0) return 0; /* Set `bytes_read' to the size of the last, probably partial, buffer; 0 < `bytes_read' <= `BUFSIZ'. */ bytes_read = pos % BUFSIZ; if (bytes_read == 0) bytes_read = BUFSIZ; /* Make `pos' a multiple of `BUFSIZ' (0 if the file is short), so that all reads will be on block boundaries, which might increase efficiency. */ pos -= bytes_read; lseek (fd, pos, SEEK_SET); bytes_read = safe_read (fd, buffer, bytes_read); if (bytes_read == -1) { error (0, errno, "%s", filename); return 1; } /* Count the incomplete line on files that don't end with a newline. */ if (bytes_read && buffer[bytes_read - 1] != '\n') --n_lines; do { /* Scan backward, counting the newlines in this bufferfull. */ for (i = bytes_read - 1; i >= 0; i--) { /* Have we counted the requested number of newlines yet? */ if (buffer[i] == '\n' && n_lines-- == 0) { /* If this newline wasn't the last character in the buffer, print the text after it. */ if (i != bytes_read - 1) XWRITE (STDOUT_FILENO, &buffer[i + 1], bytes_read - (i + 1)); return 0; } } /* Not enough newlines in that bufferfull. */ if (pos == 0) { /* Not enough lines in the file; print the entire file. */ lseek (fd, (off_t) 0, SEEK_SET); return 0; } pos -= BUFSIZ; lseek (fd, pos, SEEK_SET); } while ((bytes_read = safe_read (fd, buffer, BUFSIZ)) > 0); if (bytes_read == -1) { error (0, errno, "%s", filename); return 1; } return 0; } /* Print the last N_LINES lines from the end of the standard input, open for reading as pipe FD. Buffer the text as a linked list of LBUFFERs, adding them as needed. Return 0 if successful, 1 if an error occured. */ static int pipe_lines (filename, fd, n_lines) const char *filename; int fd; long n_lines; { struct linebuffer { int nbytes, nlines; char buffer[BUFSIZ]; struct linebuffer *next; }; typedef struct linebuffer LBUFFER; LBUFFER *first, *last, *tmp; int i; /* Index into buffers. */ int total_lines = 0; /* Total number of newlines in all buffers. */ int errors = 0; first = last = (LBUFFER *) xmalloc (sizeof (LBUFFER)); first->nbytes = first->nlines = 0; first->next = NULL; tmp = (LBUFFER *) xmalloc (sizeof (LBUFFER)); /* Input is always read into a fresh buffer. */ while ((tmp->nbytes = safe_read (fd, tmp->buffer, BUFSIZ)) > 0) { tmp->nlines = 0; tmp->next = NULL; /* Count the number of newlines just read. */ for (i = 0; i < tmp->nbytes; i++) if (tmp->buffer[i] == '\n') ++tmp->nlines; total_lines += tmp->nlines; /* If there is enough room in the last buffer read, just append the new one to it. This is because when reading from a pipe, `nbytes' can often be very small. */ if (tmp->nbytes + last->nbytes < BUFSIZ) { memcpy (&last->buffer[last->nbytes], tmp->buffer, tmp->nbytes); last->nbytes += tmp->nbytes; last->nlines += tmp->nlines; } else { /* If there's not enough room, link the new buffer onto the end of the list, then either free up the oldest buffer for the next read if that would leave enough lines, or else malloc a new one. Some compaction mechanism is possible but probably not worthwhile. */ last = last->next = tmp; if (total_lines - first->nlines > n_lines) { tmp = first; total_lines -= first->nlines; first = first->next; } else tmp = (LBUFFER *) xmalloc (sizeof (LBUFFER)); } } if (tmp->nbytes == -1) { error (0, errno, "%s", filename); errors = 1; free ((char *) tmp); goto free_lbuffers; } free ((char *) tmp); /* This prevents a core dump when the pipe contains no newlines. */ if (n_lines == 0) goto free_lbuffers; /* Count the incomplete line on files that don't end with a newline. */ if (last->buffer[last->nbytes - 1] != '\n') { ++last->nlines; ++total_lines; } /* Run through the list, printing lines. First, skip over unneeded buffers. */ for (tmp = first; total_lines - tmp->nlines > n_lines; tmp = tmp->next) total_lines -= tmp->nlines; /* Find the correct beginning, then print the rest of the file. */ if (total_lines > n_lines) { char *cp; /* Skip `total_lines' - `n_lines' newlines. We made sure that `total_lines' - `n_lines' <= `tmp->nlines'. */ cp = tmp->buffer; for (i = total_lines - n_lines; i; --i) while (*cp++ != '\n') /* Do nothing. */ ; i = cp - tmp->buffer; } else i = 0; XWRITE (STDOUT_FILENO, &tmp->buffer[i], tmp->nbytes - i); for (tmp = tmp->next; tmp; tmp = tmp->next) XWRITE (STDOUT_FILENO, tmp->buffer, tmp->nbytes); free_lbuffers: while (first) { tmp = first->next; free ((char *) first); first = tmp; } return errors; } /* Print the last N_BYTES characters from the end of pipe FD. This is a stripped down version of pipe_lines. Return 0 if successful, 1 if an error occurred. */ static int pipe_bytes (filename, fd, n_bytes) const char *filename; int fd; off_t n_bytes; { struct charbuffer { int nbytes; char buffer[BUFSIZ]; struct charbuffer *next; }; typedef struct charbuffer CBUFFER; CBUFFER *first, *last, *tmp; int i; /* Index into buffers. */ int total_bytes = 0; /* Total characters in all buffers. */ int errors = 0; first = last = (CBUFFER *) xmalloc (sizeof (CBUFFER)); first->nbytes = 0; first->next = NULL; tmp = (CBUFFER *) xmalloc (sizeof (CBUFFER)); /* Input is always read into a fresh buffer. */ while ((tmp->nbytes = safe_read (fd, tmp->buffer, BUFSIZ)) > 0) { tmp->next = NULL; total_bytes += tmp->nbytes; /* If there is enough room in the last buffer read, just append the new one to it. This is because when reading from a pipe, `nbytes' can often be very small. */ if (tmp->nbytes + last->nbytes < BUFSIZ) { memcpy (&last->buffer[last->nbytes], tmp->buffer, tmp->nbytes); last->nbytes += tmp->nbytes; } else { /* If there's not enough room, link the new buffer onto the end of the list, then either free up the oldest buffer for the next read if that would leave enough characters, or else malloc a new one. Some compaction mechanism is possible but probably not worthwhile. */ last = last->next = tmp; if (total_bytes - first->nbytes > n_bytes) { tmp = first; total_bytes -= first->nbytes; first = first->next; } else { tmp = (CBUFFER *) xmalloc (sizeof (CBUFFER)); } } } if (tmp->nbytes == -1) { error (0, errno, "%s", filename); errors = 1; free ((char *) tmp); goto free_cbuffers; } free ((char *) tmp); /* Run through the list, printing characters. First, skip over unneeded buffers. */ for (tmp = first; total_bytes - tmp->nbytes > n_bytes; tmp = tmp->next) total_bytes -= tmp->nbytes; /* Find the correct beginning, then print the rest of the file. We made sure that `total_bytes' - `n_bytes' <= `tmp->nbytes'. */ if (total_bytes > n_bytes) i = total_bytes - n_bytes; else i = 0; XWRITE (STDOUT_FILENO, &tmp->buffer[i], tmp->nbytes - i); for (tmp = tmp->next; tmp; tmp = tmp->next) XWRITE (STDOUT_FILENO, tmp->buffer, tmp->nbytes); free_cbuffers: while (first) { tmp = first->next; free ((char *) first); first = tmp; } return errors; } /* Skip N_BYTES characters from the start of pipe FD, and print any extra characters that were read beyond that. Return 1 on error, 0 if ok. */ static int start_bytes (filename, fd, n_bytes) const char *filename; int fd; off_t n_bytes; { char buffer[BUFSIZ]; int bytes_read = 0; while (n_bytes > 0 && (bytes_read = safe_read (fd, buffer, BUFSIZ)) > 0) n_bytes -= bytes_read; if (bytes_read == -1) { error (0, errno, "%s", filename); return 1; } else if (n_bytes < 0) XWRITE (STDOUT_FILENO, &buffer[bytes_read + n_bytes], -n_bytes); return 0; } /* Skip N_LINES lines at the start of file or pipe FD, and print any extra characters that were read beyond that. Return 1 on error, 0 if ok. */ static int start_lines (filename, fd, n_lines) const char *filename; int fd; long n_lines; { char buffer[BUFSIZ]; int bytes_read = 0; int bytes_to_skip = 0; while (n_lines && (bytes_read = safe_read (fd, buffer, BUFSIZ)) > 0) { bytes_to_skip = 0; while (bytes_to_skip < bytes_read) if (buffer[bytes_to_skip++] == '\n' && --n_lines == 0) break; } if (bytes_read == -1) { error (0, errno, "%s", filename); return 1; } else if (bytes_to_skip < bytes_read) { XWRITE (STDOUT_FILENO, &buffer[bytes_to_skip], bytes_read - bytes_to_skip); } return 0; } /* Display file FILENAME from the current position in FD to the end. If `forever' is nonzero, keep reading from the end of the file until killed. Return the number of bytes read from the file. */ static long dump_remainder (filename, fd) const char *filename; int fd; { char buffer[BUFSIZ]; int bytes_read; long total; total = 0; output: while ((bytes_read = safe_read (fd, buffer, BUFSIZ)) > 0) { XWRITE (STDOUT_FILENO, buffer, bytes_read); total += bytes_read; } if (bytes_read == -1) error (1, errno, "%s", filename); if (forever) { fflush (stdout); sleep (1); goto output; } return total; } /* Tail NFILES (>1) files forever until killed. The file names are in NAMES. The open file descriptors are in `file_descs', and the size at which we stopped tailing them is in `file_sizes'. We loop over each of them, doing an fstat to see if they have changed size. If none of them have changed size in one iteration, we sleep for a second and try again. We do this until the user interrupts us. */ static void tail_forever (names, nfiles) char **names; int nfiles; { int last; last = -1; while (1) { int i; int changed; changed = 0; for (i = 0; i < nfiles; i++) { struct stat stats; if (file_descs[i] < 0) continue; if (fstat (file_descs[i], &stats) < 0) { error (0, errno, "%s", names[i]); file_descs[i] = -1; continue; } if (stats.st_size == file_sizes[i]) continue; /* This file has changed size. Print out what we can, and then keep looping. */ changed = 1; if (stats.st_size < file_sizes[i]) { write_header (names[i], "file truncated"); last = i; lseek (file_descs[i], stats.st_size, SEEK_SET); file_sizes[i] = stats.st_size; continue; } if (i != last) { if (print_headers) write_header (names[i], NULL); last = i; } file_sizes[i] += dump_remainder (names[i], file_descs[i]); } /* If none of the files changed size, sleep. */ if (! changed) sleep (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]... [FILE]...\n\ ", program_name); printf ("\ Print last 10 lines of each FILE to standard output.\n\ With more than one FILE, precede each with a header giving the file name.\n\ With no FILE, or when FILE is -, read standard input.\n\ \n\ -c, --bytes=N output the last N bytes\n\ -f, --follow output appended data as the file grows\n\ -n, --lines=N output the last N lines, instead of last 10\n\ -q, --quiet, --silent never output headers giving file names\n\ -v, --verbose always output headers giving file names\n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ If the first character of N (the number of bytes or lines) is a `+',\n\ print beginning with the Nth item from the start of each file, otherwise,\n\ print the last N items in the file. N may have a multiplier suffix:\n\ b for 512, k for 1024, m for 1048576 (1 Meg). A first OPTION of -VALUE\n\ or +VALUE is treated like -n VALUE or -n +VALUE unless VALUE has one of\n\ the [bkm] suffix multipliers, in which case it is treated like -c VALUE\n\ or -c +VALUE.\n\ "); } exit (status); } textutils-1.12/src/tr.c100666 74504 13 150720 5770310656 14222 0ustar meyeringuser/* tr -- a filter to translate characters Copyright (C) 1991, 1995 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* Written by Jim Meyering, meyering@cs.utexas.edu. */ #include /* Get isblank from GNU libc. */ #define _GNU_SOURCE #include #define NDEBUG 1 #include #include #include #include #include "system.h" #include "version.h" #include "error.h" #ifndef ULONG_MAX #define ULONG_MAX ((unsigned long) ~(unsigned long) 0) #endif #ifndef LONG_MAX #define LONG_MAX ((long int) (ULONG_MAX >> 1)) #endif #ifndef UCHAR_MAX #define UCHAR_MAX 0xFF #endif #define N_CHARS (UCHAR_MAX + 1) /* A pointer to a function that returns an int. */ typedef int (*PFI) (); /* Convert from character C to its index in the collating sequence array. Just cast to an unsigned int to avoid problems with sign-extension. */ #define ORD(c) (unsigned int)(c) /* The inverse of ORD. */ #define CHR(i) (unsigned char)(i) /* The value for Spec_list->state that indicates to get_next that it should initialize the tail pointer. Its value doesn't matter as long as it can't be confused with a valid character code. */ #define BEGIN_STATE (2 * N_CHARS) /* The value for Spec_list->state that indicates to get_next that the element pointed to by Spec_list->tail is being considered for the first time on this pass through the list -- it indicates that get_next should make any necessary initializations. */ #define NEW_ELEMENT (BEGIN_STATE + 1) /* A value distinct from any character that may have been stored in a buffer as the result of a block-read in the function squeeze_filter. */ #define NOT_A_CHAR (unsigned int)(-1) /* The following (but not CC_NO_CLASS) are indices into the array of valid character class strings. */ enum Char_class { CC_ALNUM = 0, CC_ALPHA = 1, CC_BLANK = 2, CC_CNTRL = 3, CC_DIGIT = 4, CC_GRAPH = 5, CC_LOWER = 6, CC_PRINT = 7, CC_PUNCT = 8, CC_SPACE = 9, CC_UPPER = 10, CC_XDIGIT = 11, CC_NO_CLASS = 9999 }; /* Character class to which a character (returned by get_next) belonged; but it is set only if the construct from which the character was obtained was one of the character classes [:upper:] or [:lower:]. The value is used only when translating and then, only to make sure that upper and lower class constructs have the same relative positions in string1 and string2. */ enum Upper_Lower_class { UL_LOWER = 0, UL_UPPER = 1, UL_NONE = 2 }; /* A shortcut to ensure that when constructing the translation array, one of the values returned by paired calls to get_next (from s1 and s2) is from [:upper:] and the other is from [:lower:], or neither is from upper or lower. In fact, no other character classes are allowed when translating, but that condition is tested elsewhere. This array is indexed by values of type enum Upper_Lower_class. */ static int const class_ok[3][3] = { {0, 1, 0}, {1, 0, 0}, {0, 0, 1} }; /* The type of a List_element. See build_spec_list for more details. */ enum Range_element_type { RE_NO_TYPE = 0, RE_NORMAL_CHAR, RE_RANGE, RE_CHAR_CLASS, RE_EQUIV_CLASS, RE_REPEATED_CHAR }; /* One construct in one of tr's argument strings. For example, consider the POSIX version of the classic tr command: tr -cs 'a-zA-Z_' '[\n*]' String1 has 3 constructs, two of which are ranges (a-z and A-Z), and a single normal character, `_'. String2 has one construct. */ struct List_element { enum Range_element_type type; struct List_element *next; union { int normal_char; struct /* unnamed */ { unsigned int first_char; unsigned int last_char; } range; enum Char_class char_class; int equiv_code; struct /* unnamed */ { unsigned int the_repeated_char; size_t repeat_count; } repeated_char; } u; }; /* Each of tr's argument strings is parsed into a form that is easier to work with: a linked list of constructs (struct List_element). Each Spec_list structure also encapsulates various attributes of the corresponding argument string. The attributes are used mainly to verify that the strings are valid in the context of any options specified (like -s, -d, or -c). The main exception is the member `tail', which is first used to construct the list. After construction, it is used by get_next to save its state when traversing the list. The member `state' serves a similar function. */ struct Spec_list { /* Points to the head of the list of range elements. The first struct is a dummy; its members are never used. */ struct List_element *head; /* When appending, points to the last element. When traversing via get_next(), points to the element to process next. Setting Spec_list.state to the value BEGIN_STATE before calling get_next signals get_next to initialize tail to point to head->next. */ struct List_element *tail; /* Used to save state between calls to get_next(). */ unsigned int state; /* Length, in the sense that length ('a-z[:digit:]123abc') is 42 ( = 26 + 10 + 6). */ size_t length; /* The number of [c*] and [c*0] constructs that appear in this spec. */ int n_indefinite_repeats; /* If n_indefinite_repeats is non-zero, this points to the List_element corresponding to the last [c*] or [c*0] construct encountered in this spec. Otherwise it is undefined. */ struct List_element *indefinite_repeat_element; /* Non-zero if this spec contains at least one equivalence class construct e.g. [=c=]. */ int has_equiv_class; /* Non-zero if this spec contains at least one of [:upper:] or [:lower:] class constructs. */ int has_upper_or_lower; /* Non-zero if this spec contains at least one of the character class constructs (all but upper and lower) that aren't allowed in s2. */ int has_restricted_char_class; }; char *xmalloc (); char *stpcpy (); int safe_read (); /* The name by which this program was run. */ char *program_name; /* When non-zero, each sequence in the input of a repeated character (call it c) is replaced (in the output) by a single occurrence of c for every c in the squeeze set. */ static int squeeze_repeats = 0; /* When non-zero, removes characters in the delete set from input. */ static int delete = 0; /* Use the complement of set1 in place of set1. */ static int complement = 0; /* When non-zero, this flag causes GNU tr to provide strict compliance with POSIX draft 1003.2.11.2. The POSIX spec says that when -d is used without -s, string2 (if present) must be ignored. Silently ignoring arguments is a bad idea. The default GNU behavior is to give a usage message and exit. Additionally, when this flag is non-zero, tr prints warnings on stderr if it is being used in a manner that is not portable. Applicable warnings are given by default, but are suppressed if the environment variable `POSIXLY_CORRECT' is set, since being POSIX conformant means we can't issue such messages. Warnings on the following topics are suppressed when this variable is non-zero: 1. Ambiguous octal escapes. */ static int posix_pedantic; /* When tr is performing translation and string1 is longer than string2, POSIX says that the result is undefined. That gives the implementor of a POSIX conforming version of tr two reasonable choices for the semantics of this case. * The BSD tr pads string2 to the length of string1 by repeating the last character in string2. * System V tr ignores characters in string1 that have no corresponding character in string2. That is, string1 is effectively truncated to the length of string2. When non-zero, this flag causes GNU tr to imitate the behavior of System V tr when translating with string1 longer than string2. The default is to emulate BSD tr. This flag is ignored in modes where no translation is performed. Emulating the System V tr in this exceptional case causes the relatively common BSD idiom: tr -cs A-Za-z0-9 '\012' to break (it would convert only zero bytes, rather than all non-alphanumerics, to newlines). WARNING: This switch does not provide general BSD or System V compatibility. For example, it doesn't disable the interpretation of the POSIX constructs [:alpha:], [=c=], and [c*10], so if by some unfortunate coincidence you use such constructs in scripts expecting to use some other version of tr, the scripts will break. */ static int truncate_set1 = 0; /* An alias for (!delete && non_option_args == 2). It is set in main and used there and in validate(). */ static int translating; #ifndef BUFSIZ #define BUFSIZ 8192 #endif #define IO_BUF_SIZE BUFSIZ static unsigned char io_buf[IO_BUF_SIZE]; static char const *const char_class_name[] = { "alnum", "alpha", "blank", "cntrl", "digit", "graph", "lower", "print", "punct", "space", "upper", "xdigit" }; #define N_CHAR_CLASSES (sizeof(char_class_name) / sizeof(char_class_name[0])) typedef char SET_TYPE; /* Array of boolean values. A character `c' is a member of the squeeze set if and only if in_squeeze_set[c] is true. The squeeze set is defined by the last (possibly, the only) string argument on the command line when the squeeze option is given. */ static SET_TYPE in_squeeze_set[N_CHARS]; /* Array of boolean values. A character `c' is a member of the delete set if and only if in_delete_set[c] is true. The delete set is defined by the first (or only) string argument on the command line when the delete option is given. */ static SET_TYPE in_delete_set[N_CHARS]; /* Array of character values defining the translation (if any) that tr is to perform. Translation is performed only when there are two specification strings and the delete switch is not given. */ static char xlate[N_CHARS]; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output then exit. */ static int show_version; static struct option const long_options[] = { {"complement", no_argument, NULL, 'c'}, {"delete", no_argument, NULL, 'd'}, {"squeeze-repeats", no_argument, NULL, 's'}, {"truncate-set1", no_argument, NULL, 't'}, {"help", no_argument, &show_help, 1}, {"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]... SET1 [SET2]\n\ ", program_name); printf ("\ Translate, squeeze, and/or delete characters from standard input,\n\ writing to standard output.\n\ \n\ -c, --complement first complement SET1\n\ -d, --delete delete characters in SET1, do not translate\n\ -s, --squeeze-repeats replace sequence of characters with one\n\ -t, --truncate-set1 first truncate SET1 to length of SET2\n\ --help display this help and exit\n\ --version output version information and exit\n\ "); printf ("\ \n\ SETs are specified as strings of characters. Most represent themselves.\n\ Interpreted sequences are:\n\ \n\ \\NNN character with octal value NNN (1 to 3 octal digits)\n\ \\\\ backslash\n\ \\a audible BEL\n\ \\b backspace\n\ \\f form feed\n\ \\n new line\n\ \\r return\n\ \\t horizontal tab\n\ \\v vertical tab\n\ CHAR1-CHAR2 all characters from CHAR1 to CHAR2 in ascending order\n\ [CHAR1-CHAR2] same as CHAR1-CHAR2, if both SET1 and SET2 use this\n\ [CHAR*] in SET2, copies of CHAR until length of SET1\n\ [CHAR*REPEAT] REPEAT copies of CHAR, REPEAT octal if starting with 0\n\ [:alnum:] all letters and digits\n\ [:alpha:] all letters\n\ [:blank:] all horizontal whitespace\n\ [:cntrl:] all control characters\n\ [:digit:] all digits\n\ [:graph:] all printable characters, not including space\n\ [:lower:] all lower case letters\n\ [:print:] all printable characters, including space\n\ [:punct:] all punctuation characters\n\ [:space:] all horizontal or vertical whitespace\n\ [:upper:] all upper case letters\n\ [:xdigit:] all hexadecimal digits\n\ [=CHAR=] all characters which are equivalent to CHAR\n\ "); printf ("\ \n\ Translation occurs if -d is not given and both SET1 and SET2 appear.\n\ -t may be used only when translating. SET2 is extended to length of\n\ SET1 by repeating its last character as necessary. Excess characters\n\ of SET2 are ignored. Only [:lower:] and [:upper:] are guaranteed to\n\ expand in ascending order; used in SET2 while translating, they may\n\ only be used in pairs to specify case conversion. -s uses SET1 if not\n\ translating nor deleting; else squeezing uses SET2 and occurs after\n\ translation or deletion.\n\ "); } exit (status); } /* Return non-zero if the character C is a member of the equivalence class containing the character EQUIV_CLASS. */ static int is_equiv_class_member (equiv_class, c) unsigned int equiv_class; unsigned int c; { return (equiv_class == c); } /* Return non-zero if the character C is a member of the character class CHAR_CLASS. */ static int is_char_class_member (char_class, c) enum Char_class char_class; unsigned int c; { int result; switch (char_class) { case CC_ALNUM: result = ISALNUM (c); break; case CC_ALPHA: result = ISALPHA (c); break; case CC_BLANK: result = ISBLANK (c); break; case CC_CNTRL: result = ISCNTRL (c); break; case CC_DIGIT: result = ISDIGIT (c); break; case CC_GRAPH: result = ISGRAPH (c); break; case CC_LOWER: result = ISLOWER (c); break; case CC_PRINT: result = ISPRINT (c); break; case CC_PUNCT: result = ISPUNCT (c); break; case CC_SPACE: result = ISSPACE (c); break; case CC_UPPER: result = ISUPPER (c); break; case CC_XDIGIT: result = ISXDIGIT (c); break; default: abort (); break; } return result; } /* Perform the first pass over each range-spec argument S, converting all \c and \ddd escapes to their one-byte representations. The conversion is done in-place, so S must point to writable storage. If an invalid quote sequence is found print an error message and return non-zero. Otherwise set *LEN to the length of the resulting string and return zero. The resulting array of characters may contain zero-bytes; however, on input, S is assumed to be null-terminated, and hence cannot contain actual (non-escaped) zero bytes. */ static int unquote (s, len) unsigned char *s; size_t *len; { size_t i, j; j = 0; for (i = 0; s[i]; i++) { switch (s[i]) { int c; case '\\': switch (s[i + 1]) { int oct_digit; case '\\': c = '\\'; break; case 'a': c = '\007'; break; case 'b': c = '\b'; break; case 'f': c = '\f'; break; case 'n': c = '\n'; break; case 'r': c = '\r'; break; case 't': c = '\t'; break; case 'v': c = '\v'; break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': c = s[i + 1] - '0'; oct_digit = s[i + 2] - '0'; if (0 <= oct_digit && oct_digit <= 7) { c = 8 * c + oct_digit; ++i; oct_digit = s[i + 2] - '0'; if (0 <= oct_digit && oct_digit <= 7) { if (8 * c + oct_digit < N_CHARS) { c = 8 * c + oct_digit; ++i; } else if (!posix_pedantic) { /* Any octal number larger than 0377 won't fit in 8 bits. So we stop when adding the next digit would put us over the limit and give a warning about the ambiguity. POSIX isn't clear on this, but one person has said that in his interpretation, POSIX says tr can't even give a warning. */ error (0, 0, "warning: the ambiguous octal escape \ \\%c%c%c is being\n\tinterpreted as the 2-byte sequence \\0%c%c, `%c'", s[i], s[i + 1], s[i + 2], s[i], s[i + 1], s[i + 2]); } } } break; case '\0': error (0, 0, "invalid backslash escape at end of string"); return 1; break; default: error (0, 0, "invalid backslash escape `\\%c'", s[i + 1]); return 1; break; } ++i; s[j++] = c; break; default: s[j++] = s[i]; break; } } *len = j; return 0; } /* If CLASS_STR is a valid character class string, return its index in the global char_class_name array. Otherwise, return CC_NO_CLASS. */ static enum Char_class look_up_char_class (class_str, len) const unsigned char *class_str; size_t len; { unsigned int i; for (i = 0; i < N_CHAR_CLASSES; i++) if (strncmp ((const char *) class_str, char_class_name[i], len) == 0 && strlen (char_class_name[i]) == len) return (enum Char_class) i; return CC_NO_CLASS; } /* Return a newly allocated string with a printable version of C. This function is used solely for formatting error messages. */ static char * make_printable_char (c) unsigned int c; { char *buf = xmalloc (5); assert (c < N_CHARS); if (ISPRINT (c)) { buf[0] = c; buf[1] = '\0'; } else { sprintf (buf, "\\%03o", c); } return buf; } /* Return a newly allocated copy of S which is suitable for printing. LEN is the number of characters in S. Most non-printing (isprint) characters are represented by a backslash followed by 3 octal digits. However, the characters represented by \c escapes where c is one of [abfnrtv] are represented by their 2-character \c sequences. This function is used solely for printing error messages. */ static char * make_printable_str (s, len) const unsigned char *s; size_t len; { /* Worst case is that every character expands to a backslash followed by a 3-character octal escape sequence. */ char *printable_buf = xmalloc (4 * len + 1); char *p = printable_buf; size_t i; for (i = 0; i < len; i++) { char buf[5]; char *tmp = NULL; switch (s[i]) { case '\\': tmp = "\\"; break; case '\007': tmp = "\\a"; break; case '\b': tmp = "\\b"; break; case '\f': tmp = "\\f"; break; case '\n': tmp = "\\n"; break; case '\r': tmp = "\\r"; break; case '\t': tmp = "\\t"; break; case '\v': tmp = "\\v"; break; default: if (ISPRINT (s[i])) { buf[0] = s[i]; buf[1] = '\0'; } else sprintf (buf, "\\%03o", s[i]); tmp = buf; break; } p = stpcpy (p, tmp); } return printable_buf; } /* Append a newly allocated structure representing a character C to the specification list LIST. */ static void append_normal_char (list, c) struct Spec_list *list; unsigned int c; { struct List_element *new; new = (struct List_element *) xmalloc (sizeof (struct List_element)); new->next = NULL; new->type = RE_NORMAL_CHAR; new->u.normal_char = c; assert (list->tail); list->tail->next = new; list->tail = new; } /* Append a newly allocated structure representing the range of characters from FIRST to LAST to the specification list LIST. Return non-zero if LAST precedes FIRST in the collating sequence, zero otherwise. This means that '[c-c]' is acceptable. */ static int append_range (list, first, last) struct Spec_list *list; size_t first; size_t last; { struct List_element *new; if (ORD (first) > ORD (last)) { char *tmp1 = make_printable_char (first); char *tmp2 = make_printable_char (last); error (0, 0, "range-endpoints of `%s-%s' are in reverse collating sequence order", tmp1, tmp2); free (tmp1); free (tmp2); return 1; } new = (struct List_element *) xmalloc (sizeof (struct List_element)); new->next = NULL; new->type = RE_RANGE; new->u.range.first_char = first; new->u.range.last_char = last; assert (list->tail); list->tail->next = new; list->tail = new; return 0; } /* If CHAR_CLASS_STR is a valid character class string, append a newly allocated structure representing that character class to the end of the specification list LIST and return 0. If CHAR_CLASS_STR is not a valid string, print an error message and return non-zero. */ static int append_char_class (list, char_class_str, len) struct Spec_list *list; const unsigned char *char_class_str; size_t len; { enum Char_class char_class; struct List_element *new; char_class = look_up_char_class (char_class_str, len); if (char_class == CC_NO_CLASS) { char *tmp = make_printable_str (char_class_str, len); error (0, 0, "invalid character class `%s'", tmp); free (tmp); return 1; } new = (struct List_element *) xmalloc (sizeof (struct List_element)); new->next = NULL; new->type = RE_CHAR_CLASS; new->u.char_class = char_class; assert (list->tail); list->tail->next = new; list->tail = new; return 0; } /* Append a newly allocated structure representing a [c*n] repeated character construct to the specification list LIST. THE_CHAR is the single character to be repeated, and REPEAT_COUNT is a non-negative repeat count. */ static void append_repeated_char (list, the_char, repeat_count) struct Spec_list *list; unsigned int the_char; size_t repeat_count; { struct List_element *new; new = (struct List_element *) xmalloc (sizeof (struct List_element)); new->next = NULL; new->type = RE_REPEATED_CHAR; new->u.repeated_char.the_repeated_char = the_char; new->u.repeated_char.repeat_count = repeat_count; assert (list->tail); list->tail->next = new; list->tail = new; } /* Given a string, EQUIV_CLASS_STR, from a [=str=] context and the length of that string, LEN, if LEN is exactly one, append a newly allocated structure representing the specified equivalence class to the specification list, LIST and return zero. If LEN is not 1, issue an error message and return non-zero. */ static int append_equiv_class (list, equiv_class_str, len) struct Spec_list *list; const unsigned char *equiv_class_str; size_t len; { struct List_element *new; if (len != 1) { char *tmp = make_printable_str (equiv_class_str, len); error (0, 0, "%s: equivalence class operand must be a single character", tmp); free (tmp); return 1; } new = (struct List_element *) xmalloc (sizeof (struct List_element)); new->next = NULL; new->type = RE_EQUIV_CLASS; new->u.equiv_code = *equiv_class_str; assert (list->tail); list->tail->next = new; list->tail = new; return 0; } /* Return a newly allocated copy of the substring P[FIRST_IDX..LAST_IDX]. The returned string has length LAST_IDX - FIRST_IDX + 1, may contain NUL bytes, and is *not* NUL-terminated. */ static unsigned char * substr (p, first_idx, last_idx) const unsigned char *p; size_t first_idx; size_t last_idx; { size_t len; unsigned char *tmp; assert (first_idx <= last_idx); len = last_idx - first_idx + 1; tmp = (unsigned char *) xmalloc (len); assert (first_idx <= last_idx); /* Use memcpy rather than strncpy because `p' may contain zero-bytes. */ memcpy (tmp, p + first_idx, len); return tmp; } /* Search forward starting at START_IDX for the 2-char sequence (PRE_BRACKET_CHAR,']') in the string P of length P_LEN. If such a sequence is found, return the index of the first character, otherwise return -1. P may contain zero bytes. */ static int find_closing_delim (p, start_idx, p_len, pre_bracket_char) const unsigned char *p; size_t start_idx; size_t p_len; unsigned int pre_bracket_char; { size_t i; for (i = start_idx; i < p_len - 1; i++) if (p[i] == pre_bracket_char && p[i + 1] == ']') return i; return -1; } /* Convert a string S with explicit length LEN, possibly containing embedded zero bytes, to a long integer value. If the string represents a negative value, a value larger than LONG_MAX, or if all LEN characters do not represent a valid integer, return non-zero and do not modify *VAL. Otherwise, return zero and set *VAL to the converted value. */ static int non_neg_strtol (s, len, val) const unsigned char *s; size_t len; size_t *val; { size_t i; unsigned long sum = 0; unsigned int base; if (len <= 0) return 1; if (s[0] == '0') base = 8; else if (ISDIGIT (s[0])) base = 10; else return 1; for (i = 0; i < len; i++) { unsigned int c; if (s[i] < '0') return 1; c = s[i] - '0'; if (c >= base) return 1; if (sum > (LONG_MAX - c) / base) return 1; sum = sum * base + c; } *val = sum; return 0; } /* Parse the bracketed repeat-char syntax. If the P_LEN characters beginning with P[ START_IDX ] comprise a valid [c*n] construct, return the character and the repeat count through the arg pointers, CHAR_TO_REPEAT and N, and then return the index of the closing bracket as the function value. If the second character following the opening bracket is not `*' or if no closing bracket can be found, return -1. If a closing bracket is found and the second char is `*', but the string between the `*' and `]' isn't empty, an octal number, or a decimal number, print an error message and return -2. */ static int find_bracketed_repeat (p, start_idx, p_len, char_to_repeat, n) const unsigned char *p; size_t start_idx; size_t p_len; unsigned int *char_to_repeat; size_t *n; { size_t i; assert (start_idx + 1 < p_len); if (p[start_idx + 1] != '*') return -1; for (i = start_idx + 2; i < p_len; i++) { if (p[i] == ']') { const unsigned char *digit_str; size_t digit_str_len = i - start_idx - 2; *char_to_repeat = p[start_idx]; if (digit_str_len == 0) { /* We've matched [c*] -- no explicit repeat count. */ *n = 0; return i; } /* Here, we have found [c*s] where s should be a string of octal or decimal digits. */ digit_str = &p[start_idx + 2]; if (non_neg_strtol (digit_str, digit_str_len, n)) { char *tmp = make_printable_str (digit_str, digit_str_len); error (0, 0, "invalid repeat count `%s' in [c*n] construct", tmp); free (tmp); return -2; } return i; } } return -1; /* No bracket found. */ } /* Convert string UNESACPED_STRING (which has been preprocessed to convert backslash-escape sequences) of length LEN characters into a linked list of the following 5 types of constructs: - [:str:] Character class where `str' is one of the 12 valid strings. - [=c=] Equivalence class where `c' is any single character. - [c*n] Repeat the single character `c' `n' times. n may be omitted. However, if `n' is present, it must be a non-negative octal or decimal integer. - r-s Range of characters from `r' to `s'. The second endpoint must not precede the first in the current collating sequence. - c Any other character is interpreted as itself. */ static int build_spec_list (unescaped_string, len, result) const unsigned char *unescaped_string; size_t len; struct Spec_list *result; { const unsigned char *p; size_t i; p = unescaped_string; /* The main for-loop below recognizes the 4 multi-character constructs. A character that matches (in its context) none of the multi-character constructs is classified as `normal'. Since all multi-character constructs have at least 3 characters, any strings of length 2 or less are composed solely of normal characters. Hence, the index of the outer for-loop runs only as far as LEN-2. */ for (i = 0; i + 2 < len;) { switch (p[i]) { int fall_through; case '[': fall_through = 0; switch (p[i + 1]) { int closing_delim_idx; int closing_bracket_idx; unsigned int char_to_repeat; size_t repeat_count; case ':': case '=': closing_delim_idx = find_closing_delim (p, i + 2, len, p[i + 1]); if (closing_delim_idx >= 0) { int parse_failed; unsigned char *opnd_str = substr (p, i + 2, closing_delim_idx - 1); if (p[i + 1] == ':') parse_failed = append_char_class (result, opnd_str, (closing_delim_idx - 1) - (i + 2) + 1); else parse_failed = append_equiv_class (result, opnd_str, (closing_delim_idx - 1) - (i + 2) + 1); free (opnd_str); /* Return non-zero if append_*_class reports a problem. */ if (parse_failed) return 1; else i = closing_delim_idx + 2; break; } /* Else fall through. This could be [:*] or [=*]. */ default: /* Determine whether this is a bracketed repeat range matching the RE \[.\*(dec_or_oct_number)?\]. */ closing_bracket_idx = find_bracketed_repeat (p, i + 1, len, &char_to_repeat, &repeat_count); if (closing_bracket_idx >= 0) { append_repeated_char (result, char_to_repeat, repeat_count); i = closing_bracket_idx + 1; break; } else if (closing_bracket_idx == -1) { fall_through = 1; } else /* Found a string that looked like [c*n] but the numeric part was invalid. */ return 1; break; } if (!fall_through) break; /* Here if we've tried to match [c*n], [:str:], and [=c=] and none of them fit. So we still have to consider the range `[-c' (from `[' to `c'). */ default: /* Look ahead one char for ranges like a-z. */ if (p[i + 1] == '-') { if (append_range (result, p[i], p[i + 2])) return 1; i += 3; } else { append_normal_char (result, p[i]); ++i; } break; } } /* Now handle the (2 or fewer) remaining characters p[i]..p[len - 1]. */ for (; i < len; i++) append_normal_char (result, p[i]); return 0; } /* Given a Spec_list S (with its saved state implicit in the values of its members `tail' and `state'), return the next single character in the expansion of S's constructs. If the last character of S was returned on the previous call or if S was empty, this function returns -1. For example, successive calls to get_next where S represents the spec-string 'a-d[y*3]' will return the sequence of values a, b, c, d, y, y, y, -1. Finally, if the construct from which the returned character comes is [:upper:] or [:lower:], the parameter CLASS is given a value to indicate which it was. Otherwise CLASS is set to UL_NONE. This value is used only when constructing the translation table to verify that any occurrences of upper and lower class constructs in the spec-strings appear in the same relative positions. */ static int get_next (s, class) struct Spec_list *s; enum Upper_Lower_class *class; { struct List_element *p; int return_val; int i; if (class) *class = UL_NONE; if (s->state == BEGIN_STATE) { s->tail = s->head->next; s->state = NEW_ELEMENT; } p = s->tail; if (p == NULL) return -1; switch (p->type) { case RE_NORMAL_CHAR: return_val = p->u.normal_char; s->state = NEW_ELEMENT; s->tail = p->next; break; case RE_RANGE: if (s->state == NEW_ELEMENT) s->state = ORD (p->u.range.first_char); else ++(s->state); return_val = CHR (s->state); if (s->state == ORD (p->u.range.last_char)) { s->tail = p->next; s->state = NEW_ELEMENT; } break; case RE_CHAR_CLASS: if (s->state == NEW_ELEMENT) { for (i = 0; i < N_CHARS; i++) if (is_char_class_member (p->u.char_class, i)) break; assert (i < N_CHARS); s->state = i; } assert (is_char_class_member (p->u.char_class, s->state)); return_val = CHR (s->state); for (i = s->state + 1; i < N_CHARS; i++) if (is_char_class_member (p->u.char_class, i)) break; if (i < N_CHARS) s->state = i; else { s->tail = p->next; s->state = NEW_ELEMENT; } if (class) { switch (p->u.char_class) { case CC_LOWER: *class = UL_LOWER; break; case CC_UPPER: *class = UL_UPPER; break; default: /* empty */ break; } } break; case RE_EQUIV_CLASS: /* FIXME: this assumes that each character is alone in its own equivalence class (which appears to be correct for my LC_COLLATE. But I don't know of any function that allows one to determine a character's equivalence class. */ return_val = p->u.equiv_code; s->state = NEW_ELEMENT; s->tail = p->next; break; case RE_REPEATED_CHAR: /* Here, a repeat count of n == 0 means don't repeat at all. */ if (p->u.repeated_char.repeat_count == 0) { s->tail = p->next; s->state = NEW_ELEMENT; return_val = get_next (s, class); } else { if (s->state == NEW_ELEMENT) { s->state = 0; } ++(s->state); return_val = p->u.repeated_char.the_repeated_char; if (p->u.repeated_char.repeat_count > 0 && s->state == p->u.repeated_char.repeat_count) { s->tail = p->next; s->state = NEW_ELEMENT; } } break; case RE_NO_TYPE: abort (); break; default: abort (); break; } return return_val; } /* This is a minor kludge. This function is called from get_spec_stats to determine the cardinality of a set derived from a complemented string. It's a kludge in that some of the same operations are (duplicated) performed in set_initialize. */ static int card_of_complement (s) struct Spec_list *s; { int c; int cardinality = N_CHARS; SET_TYPE in_set[N_CHARS]; memset (in_set, 0, N_CHARS * sizeof (in_set[0])); s->state = BEGIN_STATE; while ((c = get_next (s, NULL)) != -1) if (!in_set[c]++) --cardinality; return cardinality; } /* Gather statistics about the spec-list S in preparation for the tests in validate that determine the consistency of the specs. This function is called at most twice; once for string1, and again for any string2. LEN_S1 < 0 indicates that this is the first call and that S represents string1. When LEN_S1 >= 0, it is the length of the expansion of the constructs in string1, and we can use its value to resolve any indefinite repeat construct in S (which represents string2). Hence, this function has the side-effect that it converts a valid [c*] construct in string2 to [c*n] where n is large enough (or 0) to give string2 the same length as string1. For example, with the command tr a-z 'A[\n*]Z' on the second call to get_spec_stats, LEN_S1 would be 26 and S (representing string2) would be converted to 'A[\n*24]Z'. */ static void get_spec_stats (s) struct Spec_list *s; { struct List_element *p; int len = 0; s->n_indefinite_repeats = 0; s->has_equiv_class = 0; s->has_restricted_char_class = 0; s->has_upper_or_lower = 0; for (p = s->head->next; p; p = p->next) { switch (p->type) { int i; case RE_NORMAL_CHAR: ++len; break; case RE_RANGE: assert (p->u.range.last_char >= p->u.range.first_char); len += p->u.range.last_char - p->u.range.first_char + 1; break; case RE_CHAR_CLASS: for (i = 0; i < N_CHARS; i++) if (is_char_class_member (p->u.char_class, i)) ++len; switch (p->u.char_class) { case CC_UPPER: case CC_LOWER: s->has_upper_or_lower = 1; break; default: s->has_restricted_char_class = 1; break; } break; case RE_EQUIV_CLASS: for (i = 0; i < N_CHARS; i++) if (is_equiv_class_member (p->u.equiv_code, i)) ++len; s->has_equiv_class = 1; break; case RE_REPEATED_CHAR: if (p->u.repeated_char.repeat_count > 0) len += p->u.repeated_char.repeat_count; else if (p->u.repeated_char.repeat_count == 0) { s->indefinite_repeat_element = p; ++(s->n_indefinite_repeats); } break; case RE_NO_TYPE: assert (0); break; } } s->length = len; } static void get_s1_spec_stats (s1) struct Spec_list *s1; { get_spec_stats (s1); if (complement) s1->length = card_of_complement (s1); } static void get_s2_spec_stats (s2, len_s1) struct Spec_list *s2; size_t len_s1; { get_spec_stats (s2); if (len_s1 >= s2->length && s2->n_indefinite_repeats == 1) { s2->indefinite_repeat_element->u.repeated_char.repeat_count = len_s1 - s2->length; s2->length = len_s1; } } static void spec_init (spec_list) struct Spec_list *spec_list; { spec_list->head = spec_list->tail = (struct List_element *) xmalloc (sizeof (struct List_element)); spec_list->head->next = NULL; } /* This function makes two passes over the argument string S. The first one converts all \c and \ddd escapes to their one-byte representations. The second constructs a linked specification list, SPEC_LIST, of the characters and constructs that comprise the argument string. If either of these passes detects an error, this function returns non-zero. */ static int parse_str (s, spec_list) unsigned char *s; struct Spec_list *spec_list; { size_t len; if (unquote (s, &len)) return 1; if (build_spec_list (s, len, spec_list)) return 1; return 0; } /* Given two specification lists, S1 and S2, and assuming that S1->length > S2->length, append a single [c*n] element to S2 where c is the last character in the expansion of S2 and n is the difference between the two lengths. Upon successful completion, S2->length is set to S1->length. The only way this function can fail to make S2 as long as S1 is when S2 has zero-length, since in that case, there is no last character to repeat. So S2->length is required to be at least 1. Providing this functionality allows the user to do some pretty non-BSD (and non-portable) things: For example, the command tr -cs '[:upper:]0-9' '[:lower:]' is almost guaranteed to give results that depend on your collating sequence. */ static void string2_extend (s1, s2) const struct Spec_list *s1; struct Spec_list *s2; { struct List_element *p; int char_to_repeat; int i; assert (translating); assert (s1->length > s2->length); assert (s2->length > 0); p = s2->tail; switch (p->type) { case RE_NORMAL_CHAR: char_to_repeat = p->u.normal_char; break; case RE_RANGE: char_to_repeat = p->u.range.last_char; break; case RE_CHAR_CLASS: for (i = N_CHARS; i >= 0; i--) if (is_char_class_member (p->u.char_class, i)) break; assert (i >= 0); char_to_repeat = CHR (i); break; case RE_REPEATED_CHAR: char_to_repeat = p->u.repeated_char.the_repeated_char; break; case RE_EQUIV_CLASS: /* This shouldn't happen, because validate exits with an error if it finds an equiv class in string2 when translating. */ abort (); break; case RE_NO_TYPE: abort (); break; default: abort (); break; } append_repeated_char (s2, char_to_repeat, s1->length - s2->length); s2->length = s1->length; } /* Die with an error message if S1 and S2 describe strings that are not valid with the given command line switches. A side effect of this function is that if a valid [c*] or [c*0] construct appears in string2, it is converted to [c*n] with a value for n that makes s2->length == s1->length. By the same token, if the --truncate-set1 option is not given, S2 may be extended. */ static void validate (s1, s2) const struct Spec_list *s1; struct Spec_list *s2; { get_s1_spec_stats (s1); if (s1->n_indefinite_repeats > 0) { error (1, 0, "the [c*] repeat construct may not appear in string1"); } /* FIXME: it isn't clear from the POSIX spec that this is invalid, but in the spirit of the other restrictions put on translation with character classes, this seems a logical interpretation. */ if (complement && s1->has_upper_or_lower) { error (1, 0, "character classes may not be used when translating \ and complementing"); } if (s2) { get_s2_spec_stats (s2, s1->length); if (s2->has_restricted_char_class) { error (1, 0, "when translating, the only character classes that may \ appear in\n\tstring2 are `upper' and `lower'"); } if (s2->n_indefinite_repeats > 1) { error (1, 0, "only one [c*] repeat construct may appear in string2"); } if (translating) { if (s2->has_equiv_class) { error (1, 0, "[=c=] expressions may not appear in string2 \ when translating"); } if (s1->length > s2->length) { if (!truncate_set1) { /* string2 must be non-empty unless --truncate-set1 is given or string1 is empty. */ if (s2->length == 0) error (1, 0, "when not truncating set1, string2 must be non-empty"); string2_extend (s1, s2); } } if (complement && s2->has_upper_or_lower) error (1, 0, "character classes may not be used when translating \ and complementing"); } else /* Not translating. */ { if (s2->n_indefinite_repeats > 0) error (1, 0, "the [c*] construct may appear in string2 only \ when translating"); } } } /* Read buffers of SIZE bytes via the function READER (if READER is NULL, read from stdin) until EOF. When non-NULL, READER is either read_and_delete or read_and_xlate. After each buffer is read, it is processed and written to stdout. The buffers are processed so that multiple consecutive occurrences of the same character in the input stream are replaced by a single occurrence of that character if the character is in the squeeze set. */ static void squeeze_filter (buf, size, reader) unsigned char *buf; long int size; PFI reader; { unsigned int char_to_squeeze = NOT_A_CHAR; int i = 0; int nr = 0; for (;;) { int begin; if (i >= nr) { if (reader == NULL) nr = safe_read (0, (char *) buf, size); else nr = (*reader) (buf, size, NULL); if (nr < 0) error (1, errno, "read error"); if (nr == 0) break; i = 0; } begin = i; if (char_to_squeeze == NOT_A_CHAR) { int out_len; /* Here, by being a little tricky, we can get a significant performance increase in most cases when the input is reasonably large. Since tr will modify the input only if two consecutive (and identical) input characters are in the squeeze set, we can step by two through the data when searching for a character in the squeeze set. This means there may be a little more work in a few cases and perhaps twice as much work in the worst cases where most of the input is removed by squeezing repeats. But most uses of this functionality seem to remove less than 20-30% of the input. */ for (; i < nr && !in_squeeze_set[buf[i]]; i += 2) ; /* empty */ /* There is a special case when i == nr and we've just skipped a character (the last one in buf) that is in the squeeze set. */ if (i == nr && in_squeeze_set[buf[i - 1]]) --i; if (i >= nr) out_len = nr - begin; else { char_to_squeeze = buf[i]; /* We're about to output buf[begin..i]. */ out_len = i - begin + 1; /* But since we stepped by 2 in the loop above, out_len may be one too large. */ if (i > 0 && buf[i - 1] == char_to_squeeze) --out_len; /* Advance i to the index of first character to be considered when looking for a char different from char_to_squeeze. */ ++i; } if (out_len > 0 && fwrite ((char *) &buf[begin], 1, out_len, stdout) == 0) error (1, errno, "write error"); } if (char_to_squeeze != NOT_A_CHAR) { /* Advance i to index of first char != char_to_squeeze (or to nr if all the rest of the characters in this buffer are the same as char_to_squeeze). */ for (; i < nr && buf[i] == char_to_squeeze; i++) ; /* empty */ if (i < nr) char_to_squeeze = NOT_A_CHAR; /* If (i >= nr) we've squeezed the last character in this buffer. So now we have to read a new buffer and continue comparing characters against char_to_squeeze. */ } } } /* Read buffers of SIZE bytes from stdin until one is found that contains at least one character not in the delete set. Store in the array BUF, all characters from that buffer that are not in the delete set, and return the number of characters saved or 0 upon EOF. */ static long read_and_delete (buf, size, not_used) unsigned char *buf; long int size; PFI not_used; { long n_saved; static int hit_eof = 0; assert (not_used == NULL); assert (size > 0); if (hit_eof) return 0; /* This enclosing do-while loop is to make sure that we don't return zero (indicating EOF) when we've just deleted all the characters in a buffer. */ do { int i; int nr = safe_read (0, (char *) buf, size); if (nr < 0) error (1, errno, "read error"); if (nr == 0) { hit_eof = 1; return 0; } /* This first loop may be a waste of code, but gives much better performance when no characters are deleted in the beginning of a buffer. It just avoids the copying of buf[i] into buf[n_saved] when it would be a NOP. */ for (i = 0; i < nr && !in_delete_set[buf[i]]; i++) /* empty */ ; n_saved = i; for (++i; i < nr; i++) if (!in_delete_set[buf[i]]) buf[n_saved++] = buf[i]; } while (n_saved == 0); return n_saved; } /* Read at most SIZE bytes from stdin into the array BUF. Then perform the in-place and one-to-one mapping specified by the global array `xlate'. Return the number of characters read, or 0 upon EOF. */ static long read_and_xlate (buf, size, not_used) unsigned char *buf; long int size; PFI not_used; { long chars_read = 0; static int hit_eof = 0; int i; assert (not_used == NULL); assert (size > 0); if (hit_eof) return 0; chars_read = safe_read (0, (char *) buf, size); if (chars_read < 0) error (1, errno, "read error"); if (chars_read == 0) { hit_eof = 1; return 0; } for (i = 0; i < chars_read; i++) buf[i] = xlate[buf[i]]; return chars_read; } /* Initialize a boolean membership set IN_SET with the character values obtained by traversing the linked list of constructs S using the function `get_next'. If COMPLEMENT_THIS_SET is non-zero the resulting set is complemented. */ static void set_initialize (s, complement_this_set, in_set) struct Spec_list *s; int complement_this_set; SET_TYPE *in_set; { int c; int i; memset (in_set, 0, N_CHARS * sizeof (in_set[0])); s->state = BEGIN_STATE; while ((c = get_next (s, NULL)) != -1) in_set[c] = 1; if (complement_this_set) for (i = 0; i < N_CHARS; i++) in_set[i] = (!in_set[i]); } void main (argc, argv) int argc; char **argv; { int c; int non_option_args; struct Spec_list buf1, buf2; struct Spec_list *s1 = &buf1; struct Spec_list *s2 = &buf2; program_name = argv[0]; while ((c = getopt_long (argc, argv, "cdst", long_options, (int *) 0)) != EOF) { switch (c) { case 0: break; case 'c': complement = 1; break; case 'd': delete = 1; break; case 's': squeeze_repeats = 1; break; case 't': truncate_set1 = 1; break; default: usage (2); break; } } if (show_version) { printf ("tr - %s\n", version_string); exit (0); } if (show_help) usage (0); posix_pedantic = (getenv ("POSIXLY_CORRECT") != NULL); non_option_args = argc - optind; translating = (non_option_args == 2 && !delete); /* Change this test if it is valid to give tr no options and no args at all. POSIX doesn't specifically say anything either way, but it looks like they implied it's invalid by omission. If you want to make tr do a slow imitation of `cat' use `tr a a'. */ if (non_option_args > 2) { error (0, 0, "too many arguments"); usage (2); } if (!delete && !squeeze_repeats && non_option_args != 2) error (1, 0, "two strings must be given when translating"); if (delete && squeeze_repeats && non_option_args != 2) error (1, 0, "two strings must be given when both \ deleting and squeezing repeats"); /* If --delete is given without --squeeze-repeats, then only one string argument may be specified. But POSIX says to ignore any string2 in this case, so if POSIXLY_CORRECT is set, pretend we never saw string2. But I think this deserves a fatal error, so that's the default. */ if ((delete && !squeeze_repeats) && non_option_args != 1) { if (posix_pedantic && non_option_args == 2) --non_option_args; else error (1, 0, "only one string may be given when deleting \ without squeezing repeats"); } if (squeeze_repeats && non_option_args == 0) error (1, 0, "at least one string must be given when squeezing repeats"); spec_init (s1); if (parse_str ((unsigned char *) argv[optind], s1)) exit (1); if (non_option_args == 2) { spec_init (s2); if (parse_str ((unsigned char *) argv[optind + 1], s2)) exit (1); } else s2 = NULL; validate (s1, s2); if (squeeze_repeats && non_option_args == 1) { set_initialize (s1, complement, in_squeeze_set); squeeze_filter (io_buf, IO_BUF_SIZE, NULL); } else if (delete && non_option_args == 1) { int nr; set_initialize (s1, complement, in_delete_set); do { nr = read_and_delete (io_buf, IO_BUF_SIZE, NULL); if (nr > 0 && fwrite ((char *) io_buf, 1, nr, stdout) == 0) error (1, errno, "write error"); } while (nr > 0); } else if (squeeze_repeats && delete && non_option_args == 2) { set_initialize (s1, complement, in_delete_set); set_initialize (s2, 0, in_squeeze_set); squeeze_filter (io_buf, IO_BUF_SIZE, (PFI) read_and_delete); } else if (translating) { if (complement) { int i; SET_TYPE *in_s1 = in_delete_set; set_initialize (s1, 0, in_s1); s2->state = BEGIN_STATE; for (i = 0; i < N_CHARS; i++) xlate[i] = i; for (i = 0; i < N_CHARS; i++) { if (!in_s1[i]) { int ch = get_next (s2, NULL); assert (ch != -1 || truncate_set1); if (ch == -1) { /* This will happen when tr is invoked like e.g. tr -cs A-Za-z0-9 '\012'. */ break; } xlate[i] = ch; } } assert (get_next (s2, NULL) == -1 || truncate_set1); } else { int c1, c2; int i; enum Upper_Lower_class class_s1; enum Upper_Lower_class class_s2; for (i = 0; i < N_CHARS; i++) xlate[i] = i; s1->state = BEGIN_STATE; s2->state = BEGIN_STATE; for (;;) { c1 = get_next (s1, &class_s1); c2 = get_next (s2, &class_s2); if (!class_ok[(int) class_s1][(int) class_s2]) error (1, 0, "misaligned or mismatched upper and/or lower classes"); /* The following should have been checked by validate... */ if (c2 == -1) break; xlate[c1] = c2; } assert (c1 == -1 || truncate_set1); } if (squeeze_repeats) { set_initialize (s2, 0, in_squeeze_set); squeeze_filter (io_buf, IO_BUF_SIZE, (PFI) read_and_xlate); } else { int chars_read; do { chars_read = read_and_xlate (io_buf, IO_BUF_SIZE, NULL); if (chars_read > 0 && fwrite ((char *) io_buf, 1, chars_read, stdout) == 0) error (1, errno, "write error"); } while (chars_read > 0); } } if (fclose (stdout) == EOF) error (2, errno, "write error"); if (close (0) != 0) error (2, errno, "standard input"); exit (0); } textutils-1.12/src/unexpand.c100666 74504 13 24772 5770310662 15403 0ustar meyeringuser/* unexpand - convert spaces to tabs Copyright (C) 1989, 1991, 1995 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* By default, convert only maximal strings of initial blanks and tabs into tabs. Preserves backspace characters in the output; they decrement the column count for tab calculations. The default action is equivalent to -8. Options: --tabs=tab1[,tab2[,...]] -t tab1[,tab2[,...]] -tab1[,tab2[,...]] If only one tab stop is given, set the tabs tab1 spaces apart instead of the default 8. Otherwise, set the tabs at columns tab1, tab2, etc. (numbered from 0); replace any tabs beyond the tabstops given with single spaces. --all -a Use tabs wherever they would replace 2 or more spaces, not just at the beginnings of lines. David MacKenzie */ #include /* Get isblank from GNU libc. */ #define _GNU_SOURCE #include #include #include #include "system.h" #include "version.h" #include "error.h" /* The number of bytes added at a time to the amount of memory allocated for the output line. */ #define OUTPUT_BLOCK 256 /* The number of bytes added at a time to the amount of memory allocated for the list of tabstops. */ #define TABLIST_BLOCK 256 char *xmalloc (); char *xrealloc (); static FILE *next_file (); static void add_tabstop (); static void parse_tabstops (); static void unexpand (); static void usage (); static void validate_tabstops (); /* The name this program was run with. */ char *program_name; /* If nonzero, convert blanks even after nonblank characters have been read on the line. */ static int convert_entire_line; /* If nonzero, the size of all tab stops. If zero, use `tab_list' instead. */ static int tab_size; /* Array of the explicit column numbers of the tab stops; after `tab_list' is exhausted, the rest of the line is printed unchanged. The first column is column 0. */ static int *tab_list; /* The index of the first invalid element of `tab_list', where the next element can be added. */ static int first_free_tab; /* Null-terminated array of input filenames. */ static char **file_list; /* Default for `file_list' if no files are given on the command line. */ static char *stdin_argv[] = { "-", NULL }; /* Nonzero if we have ever read standard input. */ static int have_read_stdin; /* Status to return to the system. */ static int exit_status; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output then exit. */ static int show_version; static struct option const longopts[] = { {"tabs", required_argument, NULL, 't'}, {"all", no_argument, NULL, 'a'}, {"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 tabval = -1; /* Value of tabstop being read, or -1. */ int c; /* Option character. */ have_read_stdin = 0; exit_status = 0; convert_entire_line = 0; tab_list = NULL; first_free_tab = 0; program_name = argv[0]; while ((c = getopt_long (argc, argv, "at:,0123456789", longopts, (int *) 0)) != EOF) { switch (c) { case 0: break; case '?': usage (1); case 'a': convert_entire_line = 1; break; case 't': convert_entire_line = 1; parse_tabstops (optarg); break; case ',': add_tabstop (tabval); tabval = -1; break; default: if (tabval == -1) tabval = 0; tabval = tabval * 10 + c - '0'; break; } } if (show_version) { printf ("unexpand - %s\n", version_string); exit (0); } if (show_help) usage (0); add_tabstop (tabval); validate_tabstops (tab_list, first_free_tab); if (first_free_tab == 0) tab_size = 8; else if (first_free_tab == 1) tab_size = tab_list[0]; else tab_size = 0; if (optind == argc) file_list = stdin_argv; else file_list = &argv[optind]; unexpand (); if (have_read_stdin && fclose (stdin) == EOF) error (1, errno, "-"); if (fclose (stdout) == EOF) error (1, errno, "write error"); exit (exit_status); } /* Add the comma or blank separated list of tabstops STOPS to the list of tabstops. */ static void parse_tabstops (stops) char *stops; { int tabval = -1; for (; *stops; stops++) { if (*stops == ',' || ISBLANK (*stops)) { add_tabstop (tabval); tabval = -1; } else if (ISDIGIT (*stops)) { if (tabval == -1) tabval = 0; tabval = tabval * 10 + *stops - '0'; } else error (1, 0, "tab size contains an invalid character"); } add_tabstop (tabval); } /* Add tab stop TABVAL to the end of `tab_list', except if TABVAL is -1, do nothing. */ static void add_tabstop (tabval) int tabval; { if (tabval == -1) return; if (first_free_tab % TABLIST_BLOCK == 0) tab_list = (int *) xrealloc (tab_list, first_free_tab + TABLIST_BLOCK); tab_list[first_free_tab++] = tabval; } /* Check that the list of tabstops TABS, with ENTRIES entries, contains only nonzero, ascending values. */ static void validate_tabstops (tabs, entries) int *tabs; int entries; { int prev_tab = 0; int i; for (i = 0; i < entries; i++) { if (tabs[i] == 0) error (1, 0, "tab size cannot be 0"); if (tabs[i] <= prev_tab) error (1, 0, "tab sizes must be ascending"); prev_tab = tabs[i]; } } /* Change spaces to tabs, writing to stdout. Read each file in `file_list', in order. */ static void unexpand () { FILE *fp; /* Input stream. */ int c; /* Each input character. */ /* Index in `tab_list' of next tabstop: */ int tab_index = 0; /* For calculating width of pending tabs. */ int print_tab_index = 0; /* For printing as many tabs as possible. */ int column = 0; /* Column on screen of next char. */ int next_tab_column; /* Column the next tab stop is on. */ int convert = 1; /* If nonzero, perform translations. */ int pending = 0; /* Pending columns of blanks. */ fp = next_file ((FILE *) NULL); if (fp == NULL) return; for (;;) { c = getc (fp); if (c == EOF) { fp = next_file (fp); if (fp == NULL) break; /* No more files. */ else continue; } if (c == ' ' && convert) { ++pending; ++column; } else if (c == '\t' && convert) { if (tab_size == 0) { /* Do not let tab_index == first_free_tab; stop when it is 1 less. */ while (tab_index < first_free_tab - 1 && column >= tab_list[tab_index]) tab_index++; next_tab_column = tab_list[tab_index]; if (tab_index < first_free_tab - 1) tab_index++; if (column >= next_tab_column) { convert = 0; /* Ran out of tab stops. */ goto flush_pend; } } else { next_tab_column = column + tab_size - column % tab_size; } pending += next_tab_column - column; column = next_tab_column; } else { flush_pend: /* Flush pending spaces. Print as many tabs as possible, then print the rest as spaces. */ if (pending == 1) { putchar (' '); pending = 0; } column -= pending; while (pending != 0) { if (tab_size == 0) { /* Do not let tab_index == first_free_tab; stop when it is 1 less. */ while (tab_index < first_free_tab - 1 && column >= tab_list[tab_index]) print_tab_index++; next_tab_column = tab_list[print_tab_index]; if (print_tab_index < first_free_tab - 1) print_tab_index++; } else { next_tab_column = column + tab_size - column % tab_size; } if (next_tab_column - column <= pending) { putchar ('\t'); pending -= next_tab_column - column; column = next_tab_column; } else { --print_tab_index; column += pending; while (pending != 0) { putchar (' '); pending--; } } } if (convert) { if (c == '\b') { if (column > 0) --column; } else { ++column; if (convert_entire_line == 0) convert = 0; } } putchar (c); if (c == '\n') { tab_index = print_tab_index = 0; column = pending = 0; convert = 1; } } } } /* Close the old stream pointer FP if it is non-NULL, and return a new one opened to read the next input file. Open a filename of `-' as the standard input. Return NULL if there are no more input files. */ static FILE * next_file (fp) FILE *fp; { static char *prev_file; char *file; if (fp) { if (ferror (fp)) { error (0, errno, "%s", prev_file); exit_status = 1; } if (fp == stdin) clearerr (fp); /* Also clear EOF. */ else if (fclose (fp) == EOF) { error (0, errno, "%s", prev_file); exit_status = 1; } } while ((file = *file_list++) != NULL) { if (file[0] == '-' && file[1] == '\0') { have_read_stdin = 1; prev_file = file; return stdin; } fp = fopen (file, "r"); if (fp) { prev_file = file; return fp; } error (0, errno, "%s", file); exit_status = 1; } return NULL; } 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 ("\ Convert spaces in each FILE to tabs, writing to standard output.\n\ With no FILE, or when FILE is -, read standard input.\n\ \n\ -a, --all convert all whitespace, instead of initial whitespace\n\ -t, --tabs=NUMBER have tabs NUMBER characters apart instead of 8\n\ -t, --tabs=LIST use comma separated list of explicit tab positions\n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ Instead of -t NUMBER or -t LIST, -NUMBER or -LIST may be used.\n\ "); } exit (status); } textutils-1.12/src/uniq.c100666 74504 13 21346 5770310674 14532 0ustar meyeringuser/* uniq -- remove duplicate lines from a sorted file Copyright (C) 1986, 1991, 1995 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* Written by Richard Stallman and David MacKenzie. */ #include /* Get isblank from GNU libc. */ #define _GNU_SOURCE #include #include #include #include "system.h" #include "linebuffer.h" #include "version.h" #include "error.h" #define min(x, y) ((x) < (y) ? (x) : (y)) static char *find_field (); static int different (); static void check_file (); static void usage (); static void writeline (); /* The name this program was run with. */ char *program_name; /* Number of fields to skip on each line when doing comparisons. */ static int skip_fields; /* Number of chars to skip after skipping any fields. */ static int skip_chars; /* Number of chars to compare; if 0, compare the whole lines. */ static int check_chars; enum countmode { count_occurrences, /* -c Print count before output lines. */ count_none /* Default. Do not print counts. */ }; /* Whether and how to precede the output lines with a count of the number of times they occurred in the input. */ static enum countmode countmode; enum output_mode { output_repeated, /* -d Only lines that are repeated. */ output_unique, /* -u Only lines that are not repeated. */ output_all /* Default. Print first copy of each line. */ }; /* Which lines to output. */ static enum output_mode mode; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output then exit. */ static int show_version; static struct option const longopts[] = { {"count", no_argument, NULL, 'c'}, {"repeated", no_argument, NULL, 'd'}, {"unique", no_argument, NULL, 'u'}, {"skip-fields", required_argument, NULL, 'f'}, {"skip-chars", required_argument, NULL, 's'}, {"check-chars", required_argument, NULL, 'w'}, {"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; char *infile = "-", *outfile = "-"; program_name = argv[0]; skip_chars = 0; skip_fields = 0; check_chars = 0; mode = output_all; countmode = count_none; while ((optc = getopt_long (argc, argv, "0123456789cdf:s:uw:", longopts, (int *) 0)) != EOF) { switch (optc) { case 0: break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': skip_fields = skip_fields * 10 + optc - '0'; break; case 'c': countmode = count_occurrences; break; case 'd': mode = output_repeated; break; case 'f': /* Like '-#'. */ skip_fields = atoi (optarg); break; case 's': /* Like '+#'. */ skip_chars = atoi (optarg); break; case 'u': mode = output_unique; break; case 'w': check_chars = atoi (optarg); break; default: usage (1); } } if (show_version) { printf ("uniq - %s\n", version_string); exit (0); } if (show_help) usage (0); if (optind >= 2 && strcmp (argv[optind - 1], "--") != 0) { /* Interpret non-option arguments with leading `+' only if we haven't seen `--'. */ while (optind < argc && argv[optind][0] == '+') skip_chars = atoi (argv[optind++]); } if (optind < argc) infile = argv[optind++]; if (optind < argc) outfile = argv[optind++]; if (optind < argc) usage (1); /* Extra arguments. */ check_file (infile, outfile); exit (0); } /* Process input file INFILE with output to OUTFILE. If either is "-", use the standard I/O stream for it instead. */ static void check_file (infile, outfile) char *infile, *outfile; { FILE *istream; FILE *ostream; struct linebuffer lb1, lb2; struct linebuffer *thisline, *prevline, *exch; char *prevfield, *thisfield; int prevlen, thislen; int match_count = 0; if (!strcmp (infile, "-")) istream = stdin; else istream = fopen (infile, "r"); if (istream == NULL) error (1, errno, "%s", infile); if (!strcmp (outfile, "-")) ostream = stdout; else ostream = fopen (outfile, "w"); if (ostream == NULL) error (1, errno, "%s", outfile); thisline = &lb1; prevline = &lb2; initbuffer (thisline); initbuffer (prevline); if (readline (prevline, istream) == 0) goto closefiles; prevfield = find_field (prevline); prevlen = prevline->length - (prevfield - prevline->buffer); while (!feof (istream)) { if (readline (thisline, istream) == 0) break; thisfield = find_field (thisline); thislen = thisline->length - (thisfield - thisline->buffer); if (!different (thisfield, prevfield, thislen, prevlen)) match_count++; else { writeline (prevline, ostream, match_count); match_count = 0; exch = prevline; prevline = thisline; thisline = exch; prevfield = thisfield; prevlen = thislen; } } writeline (prevline, ostream, match_count); closefiles: if (ferror (istream) || fclose (istream) == EOF) error (1, errno, "error reading %s", infile); if (ferror (ostream) || fclose (ostream) == EOF) error (1, errno, "error writing %s", outfile); free (lb1.buffer); free (lb2.buffer); } /* Given a linebuffer LINE, return a pointer to the beginning of the line's field to be compared. */ static char * find_field (line) struct linebuffer *line; { register int count; register char *lp = line->buffer; register int size = line->length; register int i = 0; for (count = 0; count < skip_fields && i < size; count++) { while (i < size && ISBLANK (lp[i])) i++; while (i < size && !ISBLANK (lp[i])) i++; } for (count = 0; count < skip_chars && i < size; count++) i++; return lp + i; } /* Return zero if two strings OLD and NEW match, nonzero if not. OLD and NEW point not to the beginnings of the lines but rather to the beginnings of the fields to compare. OLDLEN and NEWLEN are their lengths. */ static int different (old, new, oldlen, newlen) char *old; char *new; int oldlen; int newlen; { register int order; if (check_chars) { if (oldlen > check_chars) oldlen = check_chars; if (newlen > check_chars) newlen = check_chars; } order = memcmp (old, new, min (oldlen, newlen)); if (order == 0) return oldlen - newlen; return order; } /* Output the line in linebuffer LINE to stream STREAM provided that the switches say it should be output. If requested, print the number of times it occurred, as well; LINECOUNT + 1 is the number of times that the line occurred. */ static void writeline (line, stream, linecount) struct linebuffer *line; FILE *stream; int linecount; { if ((mode == output_unique && linecount != 0) || (mode == output_repeated && linecount == 0)) return; if (countmode == count_occurrences) fprintf (stream, "%7d\t", linecount + 1); fwrite (line->buffer, sizeof (char), line->length, stream); putc ('\n', stream); } 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]... [INPUT [OUTPUT]]\n\ ", program_name); printf ("\ Discard all but one of successive identical lines from INPUT (or\n\ standard input), writing to OUTPUT (or standard output).\n\ \n\ -c, --count prefix lines by the number of occurrences\n\ -d, --repeated only print duplicate lines\n\ -f, --skip-fields=N avoid comparing the N first fields\n\ -s, --skip-chars=N avoid comparing the N first characters\n\ -u, --unique only print unique lines\n\ -w, --check-chars=N compare no more then N characters in lines\n\ -N same as -f N\n\ +N same as -s N\n\ --help display this help and exit\n\ --version output version information and exit\n\ \n\ A field is a run of whitespace, than non-whitespace characters.\n\ Fields are skipped before chars. \n\ "); } exit (status); } textutils-1.12/src/wc.c100666 74504 13 16366 5770310700 14163 0ustar meyeringuser/* wc - print the number of bytes, words, and lines in files Copyright (C) 1985, 1991, 1995 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* Written by Paul Rubin, phr@ocf.berkeley.edu and David MacKenzie, djm@gnu.ai.mit.edu. */ #include #include #include #include #include "system.h" #include "version.h" #include "error.h" /* Size of atomic reads. */ #define BUFFER_SIZE (16 * 1024) int safe_read (); static void wc (); static void wc_file (); static void write_counts (); /* The name this program was run with. */ char *program_name; /* Cumulative number of lines, words, and chars in all files so far. */ static unsigned long total_lines, total_words, total_chars; /* Which counts to print. */ static int print_lines, print_words, print_chars; /* Nonzero if we have ever read the standard input. */ static int have_read_stdin; /* The error code to return to the system. */ static int exit_status; /* If non-zero, display usage information and exit. */ static int show_help; /* If non-zero, print the version on standard output then exits. */ static int show_version; static struct option const longopts[] = { {"bytes", no_argument, NULL, 'c'}, {"chars", no_argument, NULL, 'c'}, {"lines", no_argument, NULL, 'l'}, {"words", no_argument, NULL, 'w'}, {"help", no_argument, &show_help, 1}, {"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 ("\ Print line, word, and byte counts for each FILE, and a total line if\n\ more than one FILE is specified. With no FILE, or when FILE is -,\n\ read standard input.\n\ -l, --lines print the newline counts\n\ -w, --words print the word counts\n\ -c, --bytes, --chars print the byte counts\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 optc; int nfiles; program_name = argv[0]; exit_status = 0; print_lines = print_words = print_chars = 0; total_lines = total_words = total_chars = 0; while ((optc = getopt_long (argc, argv, "clw", longopts, (int *) 0)) != EOF) switch (optc) { case 0: break; case 'c': print_chars = 1; break; case 'l': print_lines = 1; break; case 'w': print_words = 1; break; default: usage (1); } if (show_version) { printf ("wc - %s\n", version_string); exit (0); } if (show_help) usage (0); if (print_lines + print_words + print_chars == 0) print_lines = print_words = print_chars = 1; nfiles = argc - optind; if (nfiles == 0) { have_read_stdin = 1; wc (0, ""); } else { for (; optind < argc; ++optind) wc_file (argv[optind]); if (nfiles > 1) write_counts (total_lines, total_words, total_chars, "total"); } if (have_read_stdin && close (0)) error (1, errno, "-"); exit (exit_status); } static void wc_file (file) char *file; { if (!strcmp (file, "-")) { have_read_stdin = 1; wc (0, file); } else { int fd = open (file, O_RDONLY); if (fd == -1) { error (0, errno, "%s", file); exit_status = 1; return; } wc (fd, file); if (close (fd)) { error (0, errno, "%s", file); exit_status = 1; } } } static void wc (fd, file) int fd; char *file; { char buf[BUFFER_SIZE + 1]; register int bytes_read; register int in_word = 0; register unsigned long lines, words, chars; lines = words = chars = 0; /* When counting only bytes, save some line- and word-counting overhead. If FD is a `regular' Unix file, using lseek is enough to get its `size' in bytes. Otherwise, read blocks of BUFFER_SIZE bytes at a time until EOF. Note that the `size' (number of bytes) that wc reports is smaller than stats.st_size when the file is not positioned at its beginning. That's why the lseek calls below are necessary. For example the command `(dd ibs=99k skip=1 count=0; ./wc -c) < /etc/group' should make wc report `0' bytes. */ if (print_chars && !print_words && !print_lines) { off_t current_pos, end_pos; struct stat stats; if (fstat (fd, &stats) == 0 && S_ISREG (stats.st_mode) && (current_pos = lseek (fd, (off_t) 0, SEEK_CUR)) != -1 && (end_pos = lseek (fd, (off_t) 0, SEEK_END)) != -1) { off_t diff; /* Be careful here. The current position may actually be beyond the end of the file. As in the example above. */ chars = (diff = end_pos - current_pos) < 0 ? 0 : diff; } else { while ((bytes_read = safe_read (fd, buf, BUFFER_SIZE)) > 0) { chars += bytes_read; } if (bytes_read < 0) { error (0, errno, "%s", file); exit_status = 1; } } } else if (!print_words) { /* Use a separate loop when counting only lines or lines and bytes -- but not words. */ while ((bytes_read = safe_read (fd, buf, BUFFER_SIZE)) > 0) { register char *p = buf; while ((p = memchr (p, '\n', (buf + bytes_read) - p))) { ++p; ++lines; } chars += bytes_read; } if (bytes_read < 0) { error (0, errno, "%s", file); exit_status = 1; } } else { while ((bytes_read = safe_read (fd, buf, BUFFER_SIZE)) > 0) { register char *p = buf; chars += bytes_read; do { switch (*p++) { case '\n': lines++; /* Fall through. */ case '\r': case '\f': case '\t': case '\v': case ' ': if (in_word) { in_word = 0; words++; } break; default: in_word = 1; break; } } while (--bytes_read); } if (bytes_read < 0) { error (0, errno, "%s", file); exit_status = 1; } if (in_word) words++; } write_counts (lines, words, chars, file); total_lines += lines; total_words += words; total_chars += chars; } static void write_counts (lines, words, chars, file) unsigned long lines, words, chars; char *file; { if (print_lines) printf ("%7lu", lines); if (print_words) { if (print_lines) putchar (' '); printf ("%7lu", words); } if (print_chars) { if (print_lines || print_words) putchar (' '); printf ("%7lu", chars); } if (*file) printf (" %s", file); putchar ('\n'); } textutils-1.12/src/version.c100644 74504 13 135 5770372064 15171 0ustar meyeringuser#include #include "version.h" const char *version_string = "GNU textutils 1.12"; textutils-1.12/man/ 40777 74504 13 0 5771033601 13244 5ustar meyeringusertextutils-1.12/man/Makefile.in100666 74504 13 4571 5770310762 15422 0ustar meyeringuser# Makefile for GNU text 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. SHELL = /bin/sh srcdir = @srcdir@ VPATH = @srcdir@ prefix = @prefix@ exec_prefix = @exec_prefix@ mandir = $(prefix)/man/man1 bindir = $(exec_prefix)/bin manext = 1 INSTALL = @INSTALL@ INSTALL_DATA = @INSTALL_DATA@ RM = rm MANFILES = cat.1 cksum.1 comm.1 csplit.1 cut.1 expand.1 fmt.1 fold.1 head.1 \ join.1 md5sum.1 nl.1 od.1 paste.1 pr.1 sort.1 split.1 sum.1 tac.1 tail.1 \ tr.1 unexpand.1 uniq.1 wc.1 DISTFILES = Makefile.in $(MANFILES) all: .SUFFIXES: subdir = man Makefile: ../config.status Makefile.in cd .. && CONFIG_FILES=$(subdir)/$@ CONFIG_HEADERS= ./config.status installdirs: $(srcdir)/../mkinstalldirs $(mandir) transform = @program_transform_name@ install: install-exec install-data install-exec: install-data: $(MANFILES) installdirs for f in $(MANFILES); do \ name=`basename $$f 1`; \ $(INSTALL_DATA) $(srcdir)/$$f \ $(mandir)/`echo $$name|sed '$(transform)'`$(manext); \ done uninstall: for f in $(MANFILES); do \ name=`basename $$f 1`; \ $(RM) -f $(mandir)/`echo $$name|sed '$(transform)'`$(manext); \ done TAGS: check: clean: mostlyclean: clean distclean: clean $(RM) -f Makefile maintainer-clean: distclean distdir = ../`cat ../distname`/$(subdir) dist: for file in $(DISTFILES); do \ ln $$file $(distdir) \ || { echo copying $$file instead; cp -p $$file $(distdir);}; \ done .PHONY: all check clean dist distclean install install-data install-exec \ installdirs maintainer-clean mostlyclean uninstall # 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: textutils-1.12/man/cat.1100666 74504 13 2621 5770034521 14174 0ustar meyeringuser.TH CAT 1L "GNU Text Utilities" "FSF" \" -*- nroff -*- .SH NAME cat \- concatenate files and print on the standard output .SH SYNOPSIS .B cat [\-benstuvAET] [\-\-number] [\-\-number-nonblank] [\-\-squeeze-blank] [\-\-show-nonprinting] [\-\-show-ends] [\-\-show-tabs] [\-\-show-all] [\-\-help] [\-\-version] [file...] .SH DESCRIPTION This manual page documents the GNU version of .BR cat . .B cat writes the contents of each given file, or the standard input if none are given or when a file named `\-' is given, to the standard output. .SS OPTIONS .TP .I "\-b, \-\-number-nonblank" Number all nonblank output lines, starting with 1. .TP .I \-e Equivalent to .IR \-vE . .TP .I "\-n, \-\-number" Number all output lines, starting with 1. .TP .I "\-s, \-\-squeeze-blank" Replace multiple adjacent blank lines with a single blank line. .TP .I \-t Equivalent to .IR \-vT . .TP .I \-u Ignored; for Unix compatibility. .TP .I "\-v, \-\-show-nonprinting" Display control characters except for LFD and TAB using `^' notation and precede characters that have the high bit set with `M-'. .TP .I "\-A, \-\-show-all" Equivalent to .IR \-vET . .TP .I "\-E, \-\-show-ends" Display a `$' after the end of each line. .TP .I "\-T, \-\-show-tabs" Display TAB characters as `^I'. .TP .I "\-\-help" Print a usage message and exit with a status code indicating success. .TP .I "\-\-version" Print version information on standard output then exit. textutils-1.12/man/cksum.1100666 74504 13 2053 5770034522 14547 0ustar meyeringuser.TH CKSUM 1L "GNU Text Utilities" "FSF" \" -*- nroff -*- .SH NAME cksum \- checksum and count the bytes in a file .SH SYNOPSIS .B cksum [\-\-help] [\-\-version] [file...] .SH DESCRIPTION This manual page documents the GNU version of .BR cksum . .B cksum computes a cyclic redundancy check (CRC) for each named file, or the standard input if none are given or when a file named `\-' is given. It prints the CRC for each file along with the number of bytes in the file, and the file name unless no arguments were given. .PP .B cksum is typically used to make sure that files have been transferred by unreliable means (such as netnews) have not been corrupted, by comparing the .B cksum output for the received files with the .B cksum output for the original files. The CRC algorithm is specified by the POSIX.2 standard. It is not compatible with the BSD or System V .B sum programs; it is more robust. .TP .I "\-\-help" Print a usage message and exit with a status code indicating success. .TP .I "\-\-version" Print version information on standard output then exit. textutils-1.12/man/comm.1100666 74504 13 1631 5770034522 14361 0ustar meyeringuser.TH COMM 1L "GNU Text Utilities" "FSF" \" -*- nroff -*- .SH NAME comm \- compare two sorted files line by line .SH SYNOPSIS .B comm [\-123] [\-\-help] [\-\-version] file1 file2 .SH DESCRIPTION This manual page documents the GNU version of .BR comm . .B comm prints lines that are common, and lines that are unique, to two input files. The two files must be sorted before .B comm can be used. The file name `\-' means the standard input. .PP With no options, .B comm produces three column output. Column one contains lines unique to .IR file1 , column two contains lines unique to .IR file2 , and column three contains lines common to both files. .SS OPTIONS .PP The options .IR \-1 , .IR \-2 , and .I \-3 suppress printing of the corresponding columns. .TP .I "\-\-help" Print a usage message and exit with a status code indicating success. .TP .I "\-\-version" Print version information on standard output then exit. textutils-1.12/man/csplit.1100666 74504 13 11176 5770034524 14753 0ustar meyeringuser.TH CSPLIT 1L "GNU Text Utilities" "FSF" \" -*- nroff -*- .SH NAME csplit \- split a file into sections determined by context lines .SH SYNOPSIS .B csplit [\-sqkz] [\-f prefix] [\-b suffix] [\-n digits] [\-\-prefix=prefix] [\-\-suffix\-format=suffix] [\-\-digits=digits] [\-\-quiet] [\-\-silent] [\-\-keep-files] [\-\-elide\-empty\-files] [\-\-help] [\-\-version] file pattern... .SH DESCRIPTION This manual page documents the GNU version of .BR csplit . .B csplit creates zero or more output files containing sections of the given input .IR file , or the standard input if the name `\-' is given. By default, .B csplit prints the number of bytes written to each output file after it has been created. .PP The contents of the output files are determined by the .I pattern arguments. An error occurs if a pattern argument refers to a nonexistent line of the input file, such as if no remaining line matches a given regular expression. After all the given patterns have been matched, any remaining output is copied into one last output file. The types of pattern arguments are: .RS .TP .I line .br Create an output file containing the current line up to (but not including) line \fIline\fP (a positive integer) of the input file. If followed by a repeat count, also create an output file containing the next \fIline\fP lines of the input file once for each repeat. .TP /\fIregexp\fP/[\fIoffset\fP] .br Create an output file containing the current line up to (but not including) the next line of the input file that contains a match for \fIregexp\fP. The optional \fIoffset\fP is a `+' or `\-' followed by a positive integer. If it is given, the input up to the matching line plus or minus \fIoffset\fP is put into the output file, and the line after that begins the next section of input. .TP %\fIregexp\fP%[\fIoffset\fP] .br Like the previous type, except that it does not create an output file, so that section of the input file is effectively ignored. .TP {\fIrepeat-count\fP} .br Repeat the previous pattern \fIrepeat-count\fP (a positive integer) additional times. An asterisk may be given in place of the (integer) repeat count, in which case the preceeding pattern is repeated as many times as necessary until the input is exausted. .RE .PP The output file names consist of a prefix followed by a suffix. By default, the suffix is merely an ascending linear sequence of two-digit decimal numbers starting with 00 and ranging up to 99, however this default may be overridden by either the .I \-\-digits option or by the .I \-\-suffix\-format option. (See below.) In any case, concatenating the output files in sorted order by file name produces the original input file, in order. The default output file name prefix is `xx'. .PP By default, if .B csplit encounters an error or receives a hangup, interrupt, quit, or terminate signal, it removes any output files that it has created so far before it exits. .SS OPTIONS .TP .I "\-f, \-\-prefix=prefix" Use .I prefix as the output file name prefix string. .TP .I "\-b, \-\-suffix\-format=suffix" Use .I suffix as the output file name suffix string. When this option is specified, the suffix string must include exactly one printf(3) style conversion specification (such as %d, possibly including format specification flags, a field width, a precision specifications, or all of these kinds of modifiers). The conversion specification must be suitable for converting a binary integer argument to readable form. Thus, only `d', 'i', `u', `o', `x', and `X' format specifiers are allowed. The entire suffix string is given (with the current output file number) to sprintf(3) to form the file name suffixes for each of the individual output files in turn. Note that when this option is used, the .I \-\-digits option is ignored. .TP .I "\-n, \-\-digits=digits" Use output file names containing numbers that are .I digits digits long instead of the default 2. .TP .I "\-k, \-\-keep-files" Do not remove output files when errors are encountered. .TP .I "\-z, \-\-elide\-empty\-files" Suppress the generation of zero-length output files. (In cases where the section delimiters of the input file are supposed to mark the first lines of each of the sections, the first output file will generally be a zero-length file unless you use this option.) Note that the output file sequence numbers will always run consecutively, starting from 0, even in cases where zero-length output sections are suppressed due to the use of this option. .TP .I "\-s, \-q, \-\-silent, \-\-quiet" Do not print counts of output file sizes. .TP .I "\-\-help" Print a usage message and exit with a status code indicating success. .TP .I "\-\-version" Print version information on standard output then exit. textutils-1.12/man/cut.1100666 74504 13 4007 5770034524 14223 0ustar meyeringuser.TH CUT 1L "GNU Text Utilities" "FSF" \" -*- nroff -*- .SH NAME cut \- remove sections from each line of files .SH SYNOPSIS .B cut {\-b byte-list, \-\-bytes=byte-list} [\-n] [\-\-help] [\-\-version] [file...] .B cut {\-c character-list, \-\-characters=character-list} [\-\-help] [\-\-version] [file...] .B cut {\-f field-list, \-\-fields=field-list} [\-d delim] [\-s] [\-\-delimiter=delim] [\-\-only-delimited] [\-\-help] [\-\-version] [file...] .SH DESCRIPTION This manual page documents the GNU version of .BR cut . .B cut prints sections of each line of each input file, or the standard input if no files are given. A file name of `-' means standard input. Which sections are printed is selected by the options. .SS OPTIONS The .IR byte-list , .IR character-list , and .I field-list are one or more numbers or ranges (two numbers separated by a dash) separated by commas. The first byte, character, and field are numbered 1. Incomplete ranges may be given: `\-m' means `1\-m'; `n\-' means `n' through end of line or last field. .TP .I "\-b, \-\-bytes byte-list" Print only the bytes in positions listed in .IR byte-list . Tabs and backspaces are treated like any other character; they take up 1 byte. .TP .I "\-c, \-\-characters character-list" Print only characters in positions listed in .IR character-list . The same as \-b for now, but internationalization will change that. Tabs and backspaces are treated like any other character; they take up 1 character. .TP .I "\-f, \-\-fields field-list" Print only the fields listed in .IR field-list . Fields are separated by a TAB by default. .TP .I "\-d, \-\-delimiter delim" For \-f, fields are separated by the first character in .I delim instead of by TAB. .TP .I \-n Do not split multibyte characters (no-op for now). .TP .I "\-s, \-\-only-delimited" For \-f, do not print lines that do not contain the field separator character. .TP .I "\-\-help" Print a usage message and exit with a status code indicating success. .TP .I "\-\-version" Print version information on standard output then exit. textutils-1.12/man/expand.1100666 74504 13 2721 5770034525 14711 0ustar meyeringuser.TH EXPAND 1L "GNU Text Utilities" "FSF" \" -*- nroff -*- .SH NAME expand \- convert tabs to spaces .SH SYNOPSIS .B expand [\-tab1[,tab2[,...]]] [\-t tab1[,tab2[,...]]] [\-i] [\-\-tabs=tab1[,tab2[,...]]] [\-\-initial] [\-\-help] [\-\-version] [file...] .SH DESCRIPTION This manual page documents the GNU version of .BR expand . .B expand writes the contents of each given file, or the standard input if none are given or when a file named `\-' is given, to the standard output, with tab characters converted to the appropriate number of spaces. By default, .B expand converts all tabs to spaces. It preserves backspace characters in the output; they decrement the column count for tab calculations. The default action is equivalent to \-8 (set tabs every 8 columns). .SS OPTIONS .TP .I "\-, \-t, \-\-tabs tab1[,tab2[,...]]" If only one tab stop is given, set the tabs \fItab1\fP spaces apart instead of the default 8. Otherwise, set the tabs at columns \fItab1\fP, \fItab2\fP, etc. (numbered from 0) and replace any tabs beyond the tabstops given with single spaces. If the tabstops are specified with the .I \-t or .I \-\-tabs option, they can be separated by blanks as well as by commas. .TP .I "\-i, \-\-initial" Only convert initial tabs (those that precede all non space or tab characters) on each line to spaces. .TP .I "\-\-help" Print a usage message and exit with a status code indicating success. .TP .I "\-\-version" Print version information on standard output then exit. textutils-1.12/man/fmt.1100666 74504 13 6131 5770034526 14220 0ustar meyeringuser.TH FMT 1L "GNU Text Utilities" "FSF" \" -*- nroff -*- .SH NAME fmt \- simple optimal text formatter .SH SYNOPSIS .B fmt [\-cstu] [\-width] [\-w width] [\-p prefix] [\-\-crown-margin] [\-\-split-only] [\-\-tagged-paragraph] [\-\-uniform-spacing] [\-\-width=width] [\-\-prefix=prefix] [\-\-help] [\-\-version] [file ...] .SH DESCRIPTION This manual page documents the GNU version of .BR fmt . .B fmt is a simple text formatter that fills and joins lines to produce output lines of (up to) the specified .I width (default 75). However .B fmt uses a .B best-fit line breaking algorithm, by a simple version of \*(lqBreaking Paragraphs into Lines\*(rq, Donald E. Knuth and Michael F. Plass, .I "Software\(emPractice and Experience" .B 11 (1981) 1119\-1184. .LP .B fmt concatenates the .IR file s listed as arguments. If none are given, .B fmt formats text from the standard input. .LP Blank lines are preserved in the output, as is the spacing between words (unless .I \-u is used). In contrast to BSD .BR fmt , tabs are expanded on input and re-introduced on output. .LP Indentation is preserved in the output, and input lines with differing indentation are not joined (unless .I \-c or .I \-t is used). Note that although the BSD .B fmt manual also states this, the BSD version does in fact join following lines with less indentation. .LP .B fmt prefers breaking lines at the end of a sentence, and tries to avoid line breaks after the first word of a sentence or before the last word of a sentence. A sentence break is defined as either the end of a paragraph or a word ending in [.?!], followed by two spaces or end of line, ignoring any intervening parentheses or quotes. .SS OPTIONS .TP .I "-c, --crown-margin" Crown margin mode. Preserve the indentation of the first two lines within a paragraph, and align the left margin of each subsequent line with that of the second line. .TP .I "-t, --tagged-paragraph" Tagged paragraph mode: just like crown mode, except that the indentation of the first line of a paragraph must be different from the indentation of the second. Otherwise the first line is treated as a one-line paragraph. .TP .I "-s, --split-only" Split lines only. Do not join short lines to form longer ones. This prevents sample lines of code, and other such \*(lqformatted\*(rq text, from being unduly combined. .TP .I "-u, --uniform-spacing" Uniform spacing. Reduce spacing between words to one space, except at the end of a sentence (two spaces). .TP .I "-width, -w width, --width=width" Fill output lines to up to .IR width " columns" (default 75). .B fmt prefers to make lines about 7% shorter, to give it room to balance line lengths. .TP .I "-p, --prefix=prefix" Only lines beginning with the prefix (possibly preceded by white space) are re-arranged; the prefix (with any preceding white space) is stripped for the formatting and re-attached to each formatted output line. One use is to format certain kinds of program comments, while leaving the code unchanged. .TP .I "\-\-help" Print a usage message and exit with a status code indicating success. .TP .I "\-\-version" Print version information on standard output then exit. textutils-1.12/man/fold.1100666 74504 13 2623 5770034526 14360 0ustar meyeringuser.TH FOLD 1L "GNU Text Utilities" "FSF" \" -*- nroff -*- .SH NAME fold \- wrap each input line to fit in specified width .SH SYNOPSIS .B fold [\-bs] [\-w width] [\-\-bytes] [\-\-spaces] [\-\-width=width] [\-\-help] [\-\-version] [file...] .SH DESCRIPTION This manual page documents the GNU version of .BR fold . .B fold prints the specified files, or the standard input when no files are given or the filename `\-' is encountered, on the standard output. It breaks long lines into multiple shorter lines by inserting a newline at column 80. It counts screen columns, so tab characters usually take more than one column, backspace characters decrease the column count, and carriage return characters set the column count back to zero. .SS OPTIONS .TP .I "\-b, \-\-bytes" Count bytes rather than columns, so that tabs, backspaces, and carriage returns are each counted as taking up one column, just like other characters. .TP .I "\-s, \-\-spaces" Break at word boundaries. If the line contains any blanks, the line is broken after the last blank that falls within the maximum line length. If there are no blanks, the line is broken at the maximum line length, as usual. .TP .I "\-w, \-\-width width" Use a maximum line length of .I width columns instead of 80. .TP .I "\-\-help" Print a usage message and exit with a status code indicating success. .TP .I "\-\-version" Print version information on standard output then exit. textutils-1.12/man/head.1100666 74504 13 2633 5770034527 14337 0ustar meyeringuser.TH HEAD 1L "GNU Text Utilities" "FSF" \" -*- nroff -*- .SH NAME head \- output the first part of files .SH SYNOPSIS .B head [\-c N[bkm]] [\-n N] [\-qv] [\-\-bytes=N[bkm]] [\-\-lines=N] [\-\-quiet] [\-\-silent] [\-\-verbose] [\-\-help] [\-\-version] [file...] .B head [\-Nbcklmqv] [file...] .SH DESCRIPTION This manual page documents the GNU version of .BR head . .B head prints the first part (10 lines by default) of each given file; it reads from standard input if no files are given or when a filename of `\-' is encountered. If more than one file is given, it prints a header consisting of the file's name enclosed in `==>' and `<==' before the output for each file. .SS OPTIONS .PP .B head accepts two option formats: the new one, in which numbers are arguments to the option letters, and the old one, in which the number precedes any option letters. .TP .I "\-c N, \-\-bytes N" Print first N bytes. N is a nonzero integer, optionally followed by one of the following characters to specify a different unit. .RS .IP b 512-byte blocks. .IP k 1-kilobyte blocks. .IP m 1-megabyte blocks. .RE .TP .I "\-n N, \-\-lines N" Print first N lines. .TP .I "\-q, \-\-quiet, \-\-silent" Never print filename headers. .TP .I "\-v, \-\-verbose" Always print filename headers. .TP .I "\-\-help" Print a usage message and exit with a status code indicating success. .TP .I "\-\-version" Print version information on standard output then exit. textutils-1.12/man/join.1100666 74504 13 5021 5464540652 14370 0ustar meyeringuser.TH JOIN 1L "GNU Text Utilities" "FSF" \" -*- nroff -*- .SH NAME join \- join lines of two files on a common field .SH SYNOPSIS .B join [\-a 1|2] [\-v 1|2] [\-e empty-string] [\-o field-list...] [\-t char] [\-j[1|2] field] [\-1 field] [\-2 field] file1 file2 .br .B join {\-\-help,\-\-version} .SH DESCRIPTION This manual page documents the GNU version of .BR join . .B join prints to the standard output a line for each pair of input lines, one each from .I file1 and .IR file2 , that have identical join fields. Either filename (but not both) can be `\-', meaning the standard input. .I file1 and .I file2 should be already sorted in increasing order (not numerically) on the join fields; unless the .I \-t option is given, they should be sorted ignoring blanks at the start of the line, as .B sort does when given the .I \-b option. .PP The defaults are: the join field is the first field in each line; fields in the input are separated by one or more blanks, with leading blanks on the line ignored; fields in the output are separated by a space; each output line consists of the join field, the remaining fields from .IR file1 , then the remaining fields from .IR file2 . .SS OPTIONS .TP .I "\-a file-number" Print a line for each unpairable line in file .I file-number (either 1 or 2), in addition to the normal output. .TP .I "\-e string" Replace empty output fields (those that are missing in the input) with .IR string . .TP .I "\-1, \-j1 field" Join on field .I field (a positive integer) of file 1. .TP .I "\-2, \-j2 field" Join on field .I field (a positive integer) of file 2. .TP .I "\-j field" Equivalent to .IR "\-1 field \-2 field" . .TP .I "\-o field-list..." Construct each output line according to the format in .IR field-list . Each element in .I field-list consists of a file number (either 1 or 2), a period, and a field number (a positive integer). The elements in the list are separated by commas or blanks. Multiple .I field-list arguments can be given after a single .I \-o option; the values of all lists given with .I \-o are concatenated together. .TP .I "\-t char" Use character .I char as the input and output field separator. .TP .I "\-v file-number" Print a line for each unpairable line in file .I file-number (either 1 or 2), instead of the normal output. .PP In addition, when GNU .B join 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. textutils-1.12/man/md5sum.1100644 74504 13 3220 5770035020 14622 0ustar meyeringuser.TH MD5SUM 1L "GNU Text Utilities" "FSF" \" -*- nroff -*- .SH NAME md5sum \- compute and check MD5 message digest .SH SYNOPSIS .B md5sum [\-bhtvV] [\-c file] [\-s[string]] [\-\-binary] [\-\-check=file] [\-\-help] [\-\-string[=string]] [\-\-text] [\-\-verbose] [\-\-version] [file...] .SH DECRIPTION This manual page documents the GNU version of .BR md5sum . .B md5sum produces for each input file an 128-bit "fingerprint" or "message-digest" or it can check with the output of a former run whether the message digests are still the same (i.e. whether the files changed). .SS OPTIONS .TP .I "\-b, \-\-binary" Treat all input files as binary. This normally does not make any difference on UN*X systems but some systems have a different internal and external representation of texts (especially the end-of-line characters). .TP .I "\-c, \-\-check=file" \fIfile\fP should be the output of a former run of .BR md5sum . The file has in each line the MD5 sum, a binary/text flag, and a file name. This file will be opened (with each possible relative path) and the message digest is computed. If it is not the same as given in this line it will be marked as failed. .TP .I "\-h \-\-help" Print an usage message and exit. .TP .I "\-s, \-\-string=string" Instead of computing the message digest for a file compute it for the given \fIstring\fP. The result is the same as for a file with contains exactly this \fIstring\fP. .TP .I "\-t, \-\-text" Treat all input files as text files. This is the reverse option to .IR \-\-binary . .TP .I "\-v, \-\-verbose" Verbosely write information about the process. .TP .I "\-V, \-\-version" Print version information on standard output then exit. textutils-1.12/man/nl.1100666 74504 13 10004 5770034530 14050 0ustar meyeringuser.TH NL 1L "GNU Text Utilities" "FSF" \" -*- nroff -*- .SH NAME nl \- number lines of files .SH SYNOPSIS .B nl [\-h header-style] [\-b body-style] [\-f footer-style] [\-p] [\-d cc] [\-v start-number] [\-i increment] [\-l lines] [\-s line-separator] [\-w line-no-width] [\-n {ln,rn,rz}] [\-\-header-numbering=style] [\-\-body-numbering=style] [\-\-footer-numbering=style] [\-\-first-page=number] [\-\-page-increment=number] [\-\-no-renumber] [\-\-join-blank-lines=number] [\-\-number-separator=string] [\-\-number-width=number] [\-\-number-format={ln,rn,rz}] [\-\-section-delimiter=cc] [\-\-help] [\-\-version] [file...] .SH DESCRIPTION This manual page documents the GNU version of .BR nl . .B nl copies each given file, or the standard input if none are given or when a file named `\-' is given, to the standard output, with line numbers added to some or all of the lines. .PP .B nl considers its input to be composed of logical pages; by default, the line number is reset to 1 at the top of each logical page. .B nl treats all of the input files as a single document; it does not reset line numbers or logical pages between files. .PP A logical page consists of three sections: header, body, and footer. Any of the sections can be empty. Each can be numbered in a different style from the others. .PP The beginnings of the sections of logical pages are indicated in the input file by a line containing nothing except one of the delimiter strings shown below: .PP .nf \e:\e:\e: start of header \e:\e: start of body \e: start of footer .fi .PP The two characters from which these strings are made can be changed with an option (see below), but the pattern and length of each string cannot be changed. .PP The section delimiter strings are replaced by an empty line on output. Any text that comes before the first section delimiter string in the input file is considered to be part of a body section, so a file that does not contain any section delimiter strings is considered to consist of a single body section. .SS OPTIONS .TP .I "\-h, \-\-header-numbering=style" See \-\-footer-numbering. .TP .I "\-b, \-\-body-numbering=style" See \-\-footer-numbering. .TP .I "\-f, \-\-footer-numbering=style" Select the numbering style for lines in the footer section of each logical page. When a line is not numbered, the current line number is not incremented, but the line number separator character is still prepended to the line. The styles are: .RS .IP a number all lines .IP t number only nonempty lines (default for body) .IP n number no lines (default for header and footer) .IP p\fIregexp\fP number only lines that contain a match for \fIregexp\fP .RE .TP .I "\-p, \-\-no-renumber" Do not reset the line number at the start of a logical page. .TP .I "\-v, \-\-first-page=number" Set the initial line number on each logical page to \fInumber\fP (default 1). .TP .I "\-i, \-\-page-increment=number" Increment line numbers by \fInumber\fP (default 1). .TP .I "\-l, \-\-join-blank-lines=number" Consider \fInumber\fP (default 1) consecutive empty lines to be one logical line for numbering, and only number the last one. Where fewer than \fInumber\fP consecutive empty lines occur, do not number them. An empty line is one that contains no characters, not even spaces or tabs. .TP .I "\-s, \-\-number-separator=string" Separate the line number from the text line in the output with \fIstring\fP (default is a TAB character). .TP .I "\-w, \-\-number-width=number" Use \fInumber\fP characters for line numbers (default 6). .TP .I "\-n, \-\-number-format={ln,rn,rz}" Select the line numbering format: .RS .IP ln left justified, no leading zeros .IP rn right justified, no leading zeros (default) .IP rz right justified, leading zeros .RE .TP .I "\-d, \-\-section-delimiter=cc" Set the two delimiter characters that indicate the beginnings of logical page sections; if only one is given, the second remains ':'. To enter '\e', use '\e\e'. .TP .I "\-\-help" Print a usage message and exit with a status code indicating success. .TP .I "\-\-version" Print version information on standard output then exit. textutils-1.12/man/od.1100666 74504 13 12745 5770034531 14060 0ustar meyeringuser.TH OD 1L "GNU Text Utilities" "FSF" \" -*- nroff -*- .SH NAME od \- dump files in octal and other formats .SH SYNOPSIS .B od [\-abcdfhiloxv] [\-s[bytes]] [\-w[bytes]] [\-A radix] [\-j bytes] [\-N bytes] [\-t type] [\-\-skip\-bytes=bytes] [\-\-address\-radix=radix] [\-\-read\-bytes=bytes] [\-\-format=type] [\-\-output\-duplicates] [\-\-strings[=bytes]] [\-\-width[=bytes]] [\-\-traditional] [\-\-help] [\-\-version] [file...] .SH DESCRIPTION This manual page documents the GNU version of .BR od . .B od writes to the standard output the contents of the given files, or of the standard input if the name `\-' is given. Each line of the output consists of the offset in the input file in the leftmost column of each line, followed by one or more columns of data from the file, in a format controlled by the options. By default, .B od prints the file offsets in octal and the file data as two-byte octal numbers. .LP .SS OPTIONS .TP .I "\-A, \-\-address\-radix=radix" Select the base in which file offsets are printed. .I radix can be one of the following: .RS .IP d decimal .IP o octal .IP x hexadecimal .IP n none (do not print offsets) .RE .sp The default is octal. .TP .I "\-j, \-\-skip\-bytes=bytes" Skip .I bytes input bytes before formatting and writing. If .B bytes begins with `0x' or `0X', it is interpreted in hexadecimal; otherwise, if it begins with `0', in octal; otherwise, in decimal. Appending `b' multiplies it by 512, `k' by 1024, and `m' by 1048576. .TP .I "\-N, \-\-read\-bytes=bytes" Only output up to .I bytes bytes of each input file. Any prefixes and suffixes on .B bytes are interpreted as for the .I \-j option. .TP .I "\-t, \-\-format=type" Select the format in which to output the file data. .I type is a string of one or more of the below type indicator characters. If you include more than one type indicator character in a single .I type string or use this option more than once, .B od writes one copy of each output line using each of the data types that you specified, in the order that you specified. .RS .IP a named character .IP c ASCII character or backslash escape .IP d signed decimal .IP f floating point .IP o octal .IP u unsigned decimal .IP x hexadecimal .RE .sp Except for types `a' and `c', you can specify the number of bytes to use in interpreting each number in the given data type by following the type indicator character with a decimal integer. Alternately, you can specify the size of one of the C compiler's built-in data types by following the type indicator character with one of the following characters. For integers (d, o, u, x): .RS .IP C char .IP S short .IP I int .IP L long .RE .sp For floating point (f): .RS .IP F float .IP D double .IP L long double .RE .TP .I "\-v, \-\-output\-duplicates" Output consecutive lines that are identical. By default, when two or more consecutive output lines would be equal, .B od outputs only the first line, and puts just an asterisk on the following line to indicate that identical lines have been elided. .TP .I "\-s, \-\-strings[=bytes]" Instead of the normal output, output only string constants in the input, which are a run of at least .I bytes ASCII graphic (or formatting) characters, terminated by a NUL. If .I bytes is omitted, it defaults to 3. .TP .I "\-w, \-\-width[=bytes]" The number of input bytes to format per output line. It must be a multiple of the least common multiple of the sizes associated with the specified output types. If .I bytes is omitted, it defaults to 32. If this option is not given, it defaults to 16. .TP .I "\-\-help" Print a usage message and exit with a status code indicating success. .TP .I "\-\-version" Print version information on standard output then exit. .PP The next several options map the old, pre-POSIX format specification options to the corresponding POSIX format specs. GNU .B od accepts any combination of old- and new-style options. Format specification options accumulate. .TP .I "\-a" Output as named characters. Equivalent to .IR "\-t a" . .TP .I "\-b" Output as octal bytes. Equivalent to .IR "\-t oC" . .TP .I "\-c" Output as ASCII characters or backslash escapes. Equivalent to .IR "\-t c" . .TP .I "\-d" Output as unsigned decimal shorts. Equivalent to .IR "\-t u2" . .TP .I "\-f" Output as floats. Equivalent to .IR "\-t fF" . .TP .I "\-h" Output as hexadecimal shorts. Equivalent to .IR "\-t x2" . .TP .I "\-i" Output as decimal shorts. Equivalent to .IR "\-t d2" . .TP .I "\-l" Output as decimal longs. Equivalent to .IR "\-t d4" . .TP .I "\-o" Output as octal shorts. Equivalent to .IR "\-t o2" . .TP .I "\-x" Output as hexadecimal shorts. Equivalent to .IR "\-t x2" . .TP .I "\-\-traditional" Recognize the pre-POSIX non-option arguments that some older versions of od accepted. The following syntax .br .B od \-\-traditional [file] [[+]offset[.][b] [[+]label[.][b]]] .br can be used to specify at most one file and optional arguments specifying an offset and a pseudo-start address, .IR "label." By default, .IR "offset" is interpreted as an octal number specifying how many input bytes to skip before formatting and writing. The optional trailing decimal point forces the interpretation of .IR "offset" as a decimal number. If no decimal is specified and the offset begins with `0x' or `0x' it is interpreted as a hexadecimal number. If there is a trailing `b', the number of bytes skipped will be .IR "offset" multiplied by 512. The label argument is interpreted just like offset, but it specifies an initial pseudo-address. The pseudo addresses are displayed in parentheses following any normal address. textutils-1.12/man/paste.1100666 74504 13 1736 5770034531 14550 0ustar meyeringuser.TH PASTE 1L "GNU Text Utilities" "FSF" \" -*- nroff -*- .SH NAME paste \- merge lines of files .SH SYNOPSIS .B paste [\-s] [\-d delim-list] [\-\-serial] [\-\-delimiters=delim-list] [\-\-help] [\-\-version] [file...] .SH DESCRIPTION This manual page documents the GNU version of .BR paste . .B paste prints lines consisting of sequentially corresponding lines of each given file, separated by TABs, terminated by a newline. If no files are given, the standard input is used. A file name of `-' means standard input. .SS OPTIONS .TP .I "\-s, \-\-serial" Paste the lines of one file at a time rather than one line from each file. .TP .I "\-d, \-\-delimiters delim-list" Consecutively use the characters in .I delim-list instead of TAB to separate merged lines. When .I delim-list is exhausted, start again at its beginning. .TP .I "\-\-help" Print a usage message and exit with a status code indicating success. .TP .I "\-\-version" Print version information on standard output then exit. textutils-1.12/man/pr.1100666 74504 13 6660 5770034532 14057 0ustar meyeringuser.TH PR 1L "GNU Text Utilities" "FSF" \" -*- nroff -*- .SH NAME pr \- convert text files for printing .SH SYNOPSIS .B pr [+PAGE] [\-COLUMN] [\-abcdfFmrtv] [\-e[in-tab-char[in-tab-width]]] [\-h header] [\-i[out-tab-char[out-tab-width]]] [\-l page-length] [\-n[number-separator[digits]]] [\-o left-margin] [\-s[column-separator]] [\-w page-width] [\-\-help] [\-\-version] [file...] .SH DESCRIPTION This manual page documents the GNU version of .BR pr . .B pr prints on the standard output a paginated and optionally multicolumn copy of the text files given on the command line, or of the standard input if no files are given or when the file name `\-' is encountered. Form feeds in the input cause page breaks in the output. .SS OPTIONS .TP .I \+PAGE Begin printing with page \fIPAGE\fP. .TP .I \-COLUMN Produce \fICOLUMN\fP-column output and print columns down. The column width is automatically decreased as \fICOLUMN\fP increases; unless you use the \fI\-w\fP option to increase the page width as well, this option might cause some columns to be truncated. .TP .I \-a Print columns across rather than down. .TP .I \-b Balance columns on the last page. .TP .I \-c Print control characters using hat notation (e.g., `^G'); print other unprintable characters in octal backslash notation. .TP .I \-d Double space the output. .TP .I "\-e[in-tab-char[in-tab-width]]" Expand tabs to spaces on input. Optional argument \fIin-tab-char\fP is the input tab character, default tab. Optional argument \fIin-tab-width\fP is the input tab character's width, default 8. .TP .I "\-F, \-f" Use a formfeed instead of newlines to separate output pages. .TP .I "\-h header" Replace the filename in the header with the string \fIheader\fP. .TP .I "\-\-help" Print a usage message and exit with a status code indicating success. .TP .I "\-i[out-tab-char[out-tab-width]]" Replace spaces with tabs on output. Optional argument \fIout-tab-char\fP is the output tab character, default tab. Optional argument \fIout-tab-width\fP is the output tab character's width, default 8. .TP .I "\-l page-length" Set the page length to \fIpage-length\fP lines. The default is 66. If \fIpage-length\fP is less than 10, the headers and footers are omitted, as if the \fI\-t\fP option had been given. .TP .I \-m Print all files in parallel, one in each column. .TP .I "\-n[number-separator[digits]]" Precede each column with a line number; with parallel files, precede each line with a line number. Optional argument \fInumber-separator\fP is the character to print after each number, default tab. Optional argument \fIdigits\fP is the number of digits per line number, default 5. .TP .I "\-o left-margin" Offset each line with a margin \fIleft-margin\fP spaces wide. The total page width is this offset plus the width set with the \fI\-w\fP option. .TP .I \-r Do not print a warning message when an argument file cannot be opened. Failure to open a file still makes the exit status nonzero, however. .TP .I "\-s[column-separator]" Separate columns by the single character \fIcolumn-separator\fP, default tab, instead of spaces. .TP .I \-t Do not print the 5-line header and the 5-line trailer that are normally on each page, and do not fill out the bottoms of pages (with blank lines or formfeeds). .TP .I \-v Print unprintable characters in octal backslash notation. .TP .I "\-\-version" Print version information on standard output then exit. .TP .I "\-w page-width" Set the page width to \fIpage-width\fP columns. The default is 72. textutils-1.12/man/sort.1100666 74504 13 16153 5701311432 14432 0ustar meyeringuser.TH SORT 1L "GNU Text Utilities" "FSF" \" -*- nroff -*- .SH NAME sort \- sort lines of text files .SH SYNOPSIS .B sort [\-cmus] [\-t separator] [\-o output-file] [\-T tempdir] [\-bdfiMnr] [+POS1 [\-POS2]] [\-k POS1[,POS2]] [file...] .br .B sort {\-\-help,\-\-version} .SH DESCRIPTION This manual page documents the GNU version of .BR sort . .B sort sorts, merges, or compares all the lines from the given files, or the standard input if no files are given. A file name of `-' means standard input. By default, .B sort writes the results to the standard output. .PP .B sort has three modes of operation: sort (the default), merge, and check for sortedness. The following options change the operation mode: .TP .I \-c Check whether the given files are already sorted: if they are not all sorted, print an error message and exit with a status of 1. .TP .I \-m Merge the given files by sorting them as a group. Each input file should already be individually sorted. It always works to sort instead of merge; merging is provided because it is faster, in the case where it works. .PP A pair of lines is compared as follows: if any key fields have been specified, .B sort compares each pair of fields, in the order specified on the command line, according to the associated ordering options, until a difference is found or no fields are left. .PP If any of the global options .I Mbdfinr are given but no key fields are specified, .B sort compares the entire lines according to the global options. .PP Finally, as a last resort when all keys compare equal (or if no ordering options were specified at all), .B sort compares the lines byte by byte in machine collating sequence. The last resort comparison honors the .I -r global option. The .I \-s (stable) option disables this last-resort comparison so that lines in which all fields compare equal are left in their original relative order. If no fields or global options are specified, .I \-s has no effect. .PP GNU .B sort has no limits on input line length or restrictions on bytes allowed within lines. In addition, if the final byte of an input file is not a newline, GNU .B sort silently supplies one. .PP If the environment variable .B TMPDIR is set, .B sort uses it as the directory in which to put temporary files instead of the default, /tmp. The .I "\-T tempdir" option is another way to select the directory for temporary files; it overrides the environment variable. .PP The following options affect the ordering of output lines. They may be specified globally or as part of a specific key field. If no key fields are specified, global options apply to comparison of entire lines; otherwise the global options are inherited by key fields that do not specify any special options of their own. .TP .I \-b Ignore leading blanks when finding sort keys in each line. .TP .I \-d Sort in `phone directory' order: ignore all characters except letters, digits and blanks when sorting. .TP .I \-f Fold lower case characters into the equivalent upper case characters when sorting so that, for example, `b' is sorted the same way `B' is. .TP .I \-i Ignore characters outside the ASCII range 040-0176 octal (inclusive) when sorting. .TP .I \-M An initial string, consisting of any amount of white space, followed by three letters abbreviating a month name, is folded to UPPER case and compared in the order `JAN' < `FEB' < ... < `DEC.' Invalid names compare low to valid names. .TP .I \-n Compare according to arithmetic value an initial numeric string consisting of optional white space, an optional \- sign, and zero or more digits, optionally followed by a decimal point and zero or more digits. .TP .I \-r Reverse the result of comparison, so that lines with greater key values appear earlier in the output instead of later. .PP Other options are: .TP .I "\-o output-file" Write output to .I output-file instead of to the standard output. If .I output-file is one of the input files, .B sort copies it to a temporary file before sorting and writing the output to .IR output-file . .TP .I "\-t separator" Use character .I separator as the field separator when finding the sort keys in each line. By default, fields are separated by the empty string between a non-whitespace character and a whitespace character. That is to say, given the input line ` foo bar', .B sort breaks it into fields ` foo' and ` bar'. The field separator is not considered to be part of either the field preceding or the field following it. .TP .I \-u For the default case or the .I \-m option, only output the first of a sequence of lines that compare equal. For the .I \-c option, check that no pair of consecutive lines compares equal. .TP .I "+POS1 [\-POS2]" Specify a field within each line to use as a sorting key. The field consists of the portion of the line starting at POS1 and up to (but not including) POS2 (or to the end of the line if POS2 is not given). The fields and character positions are numbered starting with 0. .TP .I "\-k POS1[,POS2]" An alternate syntax for specifying sorting keys. The fields and character positions are numbered starting with 1. .PP A position has the form \fIf\fP.\fIc\fP, where \fIf\fP is the number of the field to use and \fIc\fP is the number of the first character from the beginning of the field (for \fI+pos\fP) or from the end of the previous field (for \fI\-pos\fP). The .\fIc\fP part of a position may be omitted in which case it is taken to be the first character in the field. If the .I \-b option has been given, the .\fIc\fP part of a field specification is counted from the first nonblank character of the field (for \fI+pos\fP) or from the first nonblank character following the previous field (for \fI\-pos\fP). .PP A \fI+pos\fP or \fI-pos\fP argument may also have any of the option letters .I Mbdfinr appended to it, in which case the global ordering options are not used for that particular field. The .I \-b option may be independently attached to either or both of the \fI+pos\fP and \fI\-pos\fP parts of a field specification, and if it is inherited from the global options it will be attached to both. If a .I \-n or .I \-M option is used, thus implying a .I \-b option, the .I \-b option is taken to apply to both the \fI+pos\fP and the \fI\-pos\fP parts of a key specification. Keys may span multiple fields. .PP In addition, when GNU .B sort 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 COMPATIBILITY .PP Historical (BSD and System V) implementations of .B sort have differed in their interpretation of some options, particularly .IR \-b , .IR \-f , and .IR \-n . GNU sort follows the POSIX behavior, which is usually (but not always!) like the System V behavior. According to POSIX .I \-n no longer implies .IR \-b . For consistency, .I \-M has been changed in the same way. This may affect the meaning of character positions in field specifications in obscure cases. If this bites you the fix is to add an explicit .IR \-b . .SH BUGS The different meaning of field numbers depending on whether .I -k is used is confusing. It's all POSIX's fault! textutils-1.12/man/split.1100666 74504 13 3727 5770034533 14573 0ustar meyeringuser.TH SPLIT 1L "GNU Text Utilities" "FSF" \" -*- nroff -*- .SH NAME split \- split a file into pieces .SH SYNOPSIS .B split [\-lines] [\-l lines] [\-b bytes[bkm]] [\-C bytes[bkm]] [\-\-lines=lines] [\-\-bytes=bytes[bkm]] [\-\-line-bytes=bytes[bkm]] [\-\-help] [\-\-version] [infile [outfile-prefix]] .SH DESCRIPTION This manual page documents the GNU version of .BR split . .B split creates one or more output files (as many as necessary) containing consecutive sections of the .IR infile , or the standard input if none is given or the name `\-' is given. By default, .B split puts 1000 lines of the input file, or whatever is left if it is less than that, into each output file. .PP The output file names consist of a prefix followed by a group of letters, chosen so that concatenating the output files in sorted order by file name produces the original input file, in order. The default output file name prefix is `x'. If the .I outfile-prefix argument is given, it is used as the output file name prefix instead. .SS OPTIONS .TP .I "\-lines, \-l lines, \-\-lines=lines" Put .I lines lines of the input file into each output file. .TP .I "\-b bytes[bkm], \-\-bytes=bytes[bkm]" Put .I bytes bytes of the input file into each output file. .I bytes is a nonzero integer, optionally followed by one of the following characters to specify a different unit. .RS .IP b 512-byte blocks. .IP k 1-kilobyte blocks. .IP m 1-megabyte blocks. .RE .TP .I "\-C bytes[bkm], \-\-line-bytes=bytes[bkm]" Put into each output file as many complete lines of the input file as is possible without exceeding .I bytes bytes. If a line that is longer than .I bytes bytes occurs, put .I bytes bytes of it into each output file until less than .I bytes bytes of the line are left, then continue normally. .I bytes has the same format as for the .I \-\-bytes option. .TP .I "\-\-help" Print a usage message and exit with a status code indicating success. .TP .I "\-\-version" Print version information on standard output then exit. textutils-1.12/man/sum.1100666 74504 13 2561 5770034534 14240 0ustar meyeringuser.TH SUM 1L "GNU Text Utilities" "FSF" \" -*- nroff -*- .SH NAME sum \- checksum and count the blocks in a file .SH SYNOPSIS .B sum [\-rs] [\-\-sysv] [\-\-help] [\-\-version] [file...] .SH DESCRIPTION This manual page documents the GNU version of .BR sum . .B sum computes a 16-bit checksum for each named file, or the standard input if none are given or when a file named `\-' is given. It prints the checksum for each file along with the number of blocks in the file (rounded up). By default each corresponding file name is also printed if at least two arguments are specified. With the .I "\-\-sysv" option, corresponding file name are printed when there is at least one file argument. By default, the GNU .B sum computes checksums using an algorithm that is compatible with the BSD .B sum and prints file sizes in units of 1K blocks. .SS OPTIONS .TP .I \-r Use the default (BSD compatible) algorithm. This option is included for compatibility with the System V .BR sum . Unless the .I \-s option was also given, it has no effect. .TP .I "\-s, \-\-sysv" Compute checksums using an algorithm that is compatible with the one the System V .B sum uses by default and print file sizes in units of 512-byte blocks instead of 1K. .TP .I "\-\-help" Print a usage message and exit with a status code indicating success. .TP .I "\-\-version" Print version information on standard output then exit. textutils-1.12/man/tac.1100666 74504 13 2121 5770034534 14173 0ustar meyeringuser.TH TAC 1L "GNU Text Utilities" "FSF" \" -*- nroff -*- .SH NAME tac \- concatenate and print files in reverse .SH SYNOPSIS .B tac [\-br] [\-s separator] [\-\-before] [\-\-regex] [\-\-separator=separator] [\-\-help] [\-\-version] [file...] .SH DESCRIPTION This manual page documents the GNU version of .BR tac . .B tac copies each given file, or the standard input if none are given or when a file name of `-' is encountered, to the standard output with the order of the records reversed. The records are separated by instances of a string, or a newline if none is given. By default, the separator string is attached to the end of the record that it follows in the file. .SS OPTIONS .TP .I "\-b, \-\-before" The separator is attached to the beginning of the record that it precedes in the file. .TP .I "\-r, \-\-regex" The separator is a regular expression. .TP .I "\-s string, \-\-separator=string" Use .I string as the record separator. .TP .I "\-\-help" Print a usage message and exit with a status code indicating success. .TP .I "\-\-version" Print version information on standard output then exit. textutils-1.12/man/tail.1100666 74504 13 4546 5770034535 14373 0ustar meyeringuser.TH TAIL 1L "GNU Text Utilities" "FSF" \" -*- nroff -*- .SH NAME tail \- output the last part of files .SH SYNOPSIS .B tail [\-c [+]N[bkm]] [\-n [+]N] [\-fqv] [\-\-bytes=[+]N[bkm]] [\-\-lines=[+]N] [\-\-follow] [\-\-quiet] [\-\-silent] [\-\-verbose] [\-\-help] [\-\-version] [file...] .B tail [{\-,+}Nbcfklmqv] [file...] .SH DESCRIPTION This manual page documents the GNU version of .BR tail . .B tail prints the last part (10 lines by default) of each given file; it reads from standard input if no files are given or when a filename of `\-' is encountered. If more than one file is given, it prints a header consisting of the file's name enclosed in `==>' and `<==' before the output for each file. .PP The GNU .B tail can output any amount of data, unlike the Unix version, which uses a fixed size buffer. It has no .I \-r option (print in reverse). Reversing a file is really a different job from printing the end of a file; the BSD .B tail can only reverse files that are at most as large as its buffer, which is typically 32k. A reliable and more versatile way to reverse files is the GNU .B tac command. .SS OPTIONS .PP .B tail accepts two option formats: the new one, in which numbers are arguments to the option letters, and the old one, in which a `+' or `\-' and optional number precede any option letters. .PP If a number (`N') starts with a `+', .B tail begins printing with the Nth item from the start of each file, instead of from the end. .TP .I "\-c N, \-\-bytes N" Tail by N bytes. N is a nonzero integer, optionally followed by one of the following characters to specify a different unit. .RS .IP b 512-byte blocks. .IP k 1-kilobyte blocks. .IP m 1-megabyte blocks. .RE .TP .I "\-f, \-\-follow" Loop forever trying to read more characters at the end of the file, on the assumption that the file is growing. Ignored if reading from a pipe. If more than one file is given, .B tail prints a header whenever it gets output from a different file, to indicate which file that output is from. .TP .I "\-l, \-n N, \-\-lines N" Tail by N lines. .I \-l is only recognized using the old option format. .TP .I "\-q, \-\-quiet, \-\-silent" Never print filename headers. .TP .I "\-v, \-\-verbose" Always print filename headers. .TP .I "\-\-help" Print a usage message and exit with a status code indicating success. .TP .I "\-\-version" Print version information on standard output then exit. textutils-1.12/man/tr.1100666 74504 13 20741 5770034536 14103 0ustar meyeringuser.TH TR 1L "GNU Text Utilities" "FSF" \" -*- nroff -*- .SH NAME tr \- translate or delete characters .SH SYNOPSIS .B tr [\-cst] [\-\-complement] [\-\-squeeze\-repeats] [\-\-truncate\-set1] string1 string2 .br .B tr {\-s,\-\-squeeze\-repeats} [\-c] [\-\-complement] string1 .br .B tr {\-d,\-\-delete} [\-c] string1 .br .B tr {\-d,\-\-delete} {\-s,\-\-squeeze\-repeats} [\-c] [\-\-complement] string1 string2 .PP GNU .B tr also accepts the \-\-help and \-\-version options. .SH DESCRIPTION .PP This manual page documents the GNU version of .B tr. .B tr copies the standard input to the standard output, performing one of the following operations: .IP \(bu translate, and optionally squeeze repeated characters in the result .br \(bu squeeze repeated characters .br \(bu delete characters .br \(bu delete characters, then squeeze repeated characters from the result. .PP The \fIstring1\fP and (if given) \fIstring2\fP arguments define ordered sets of characters, referred to below as set1 and set2. These sets are the characters of the input that .B tr operates on. The .I \-\-complement (\fI\-c\fP) option replaces set1 with its complement (all of the characters that are not in set1). .SS "SPECIFYING SETS OF CHARACTERS" .PP The format of the \fIstring1\fP and \fIstring2\fP arguments resembles the format of regular expressions; however, they are not regular expressions, only lists of characters. Most characters simply represent themselves in these strings, but the strings can contain the shorthands listed below, for convenience. Some of them can be used only in \fIstring1\fP or \fIstring2\fP, as noted below. .PP Backslash escapes. A backslash followed by a character not listed below causes an error message. .IP \ea Control-G. .IP \eb Control-H. .IP \ef Control-L. .IP \en Control-J. .IP \er Control-M. .IP \et Control-I. .IP \ev Control-K. .IP \eooo The character with the value given by \fIooo\fP, which is 1 to 3 octal digits. .IP \e\e A backslash. .PP Ranges. The notation `\fIm\fP\-\fIn\fP' expands to all of the characters from \fIm\fP through \fIn\fP, in ascending order. \fIm\fP should collate before \fIn\fP; if it doesn't, an error results. As an example, `0\-9' is the same as `0123456789'. Although GNU .BR tr does not support the System V syntax that uses square brackets to enclose ranges, translations specified in that format will still work as long as the brackets in string1 correspond to identical brackets in string2. .PP Repeated characters. The notation `[\fIc\fP*\fIn\fP]' in \fIstring2\fP expands to \fIn\fP copies of character \fIc\fP. Thus, `[y*6]' is the same as `yyyyyy'. The notation `[\fIc\fP*]' in \fIstring2\fP expands to as many copies of \fIc\fP as are needed to make set2 as long as set1. If \fIn\fP begins with a 0, it is interpreted in octal, otherwise in decimal. .PP Character classes. The notation `[:\fIclass-name\fP:]' expands to all of the characters in the (predefined) class named \fIclass-name\fP. The characters expand in no particular order, except for the `upper' and `lower' classes, which expand in ascending order. When the .I \-\-delete (\fI\-d\fP) and .I \-\-squeeze\-repeats (\fI\-s\fP) options are both given, any character class can be used in \fIstring2\fP. Otherwise, only the character classes `lower' and `upper' are accepted in \fIstring2\fP, and then only if the corresponding character class (`upper' and `lower', respectively) is specified in the same relative position in \fIstring1\fP. Doing this specifies case conversion. The class names are given below; an error results when an invalid class name is given. .IP alnum Letters and digits. .IP alpha Letters. .IP blank Horizontal whitespace. .IP cntrl Control characters. .IP digit Digits. .IP graph Printable characters, not including space. .IP lower Lowercase letters. .IP print Printable characters, including space. .IP punct Punctuation characters. .IP space Horizontal or vertical whitespace. .IP upper Uppercase letters. .IP xdigit Hexadecimal digits. .PP Equivalence classes. The syntax `[=\fIc\fP=]' expands to all of the characters that are equivalent to \fIc\fP, in no particular order. Equivalence classes are a recent invention intended to support non-English alphabets. But there seems to be no standard way to define them or determine their contents. Therefore, they are not fully implemented in GNU .BR tr ; each character's equivalence class consists only of that character, which makes this a useless construction currently. .SS TRANSLATING .PP .B tr performs translation when \fIstring1\fP and \fIstring2\fP are both given and the \-\-delete (\fI\-d\fP) option is not given. .B tr translates each character of its input that is in set1 to the corresponding character in set2. Characters not in set1 are passed through unchanged. When a character appears more than once in set1 and the corresponding characters in set2 are not all the same, only the final one is used. For example, these two commands are equivalent: .RS .nf tr aaa xyz tr a z .fi .RE .PP A common use of .B tr is to convert lowercase characters to uppercase. This can be done in many ways. Here are three of them: .RS .nf tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ tr a-z A-Z tr '[:lower:]' '[:upper:]' .fi .RE .PP When .B tr is performing translation, set1 and set2 should normally have the same length. If set1 is shorter than set2, the extra characters at the end of set2 are ignored. .PP On the other hand, making set1 longer than set2 is not portable; POSIX.2 says that the result is undefined. In this situation, the BSD .B tr pads set2 to the length of set1 by repeating the last character of set2 as many times as necessary. The System V .B tr truncates set1 to the length of set2. .PP By default, GNU .B tr handles this case like the BSD .B tr does. When the \-\-truncate\-set1 (\fI\-t\fP) option is given, GNU .B tr handles this case like the System V .B tr instead. This option is ignored for operations other than translation. .PP Acting like the System V .B tr in this case breaks the relatively common BSD idiom: .RS .nf tr -cs A-Za-z0-9 '\e012' .fi .RE because it converts only zero bytes (the first element in the complement of set1), rather than all non-alphanumerics, to newlines. .SS "SQUEEZING REPEATS AND DELETING" .PP When given just the \-\-delete (\fI\-d\fP) option, .B tr removes any input characters that are in set1. .PP When given just the \-\-squeeze\-repeats (\fI\-s\fP) option, .B tr replaces each input sequence of a repeated character that is in set1 with a single occurrence of that character. .PP When given both the \-\-delete and the \-\-squeeze\-repeats options, .B tr first performs any deletions using set1, then squeezes repeats from any remaining characters using set2. .PP The \-\-squeeze\-repeats option may also be used when translating, in which case .B tr first performs translation, then squeezes repeats from any remaining characters using set2. .PP Here are some examples to illustrate various combinations of options: .PP Remove all zero bytes: .RS tr -d '\e000' .RE .PP Put all words on lines by themselves. This converts all non-alphanumeric characters to newlines, then squeezes each string of repeated newlines into a single newline: .RS tr -cs '[a-zA-Z0-9]' '[\en*]' .RE .PP Convert each sequence of repeated newlines to a single newline: .RS tr -s '\en' .RE .PP GNU .B tr also accepts the following options in any combination with the others. .TP .I "\-\-help" Print a usage message and exit with a status code indicating success. .TP .I "\-\-version" Print version information on standard output then exit. .SS "WARNING MESSAGES" .PP Setting the environment variable POSIXLY_CORRECT turns off several warning and error messages, for strict compliance with POSIX.2. The messages normally occur in the following circumstances: .PP 1. When the .I \-\-delete option is given but .I \-\-squeeze\-repeats is not, and \fIstring2\fP is given, GNU .B tr by default prints a usage message and exits, because \fIstring2\fP would not be used. The POSIX specification says that \fIstring2\fP must be ignored in this case. Silently ignoring arguments is a bad idea. .PP 2. When an ambiguous octal escape is given. For example, \e400 is actually \e40 followed by the digit 0, because the value 400 octal does not fit into a single byte. .PP Note that GNU .B tr does not provide complete BSD or System V compatibility. For example, there is no option to disable interpretation of the POSIX constructs [:alpha:], [=c=], and [c*10]. Also, GNU .B tr does not delete zero bytes automatically, unlike traditional UNIX versions, which provide no way to preserve zero bytes. textutils-1.12/man/unexpand.1100666 74504 13 3132 5770034537 15254 0ustar meyeringuser.TH UNEXPAND 1L "GNU Text Utilities" "FSF" \" -*- nroff -*- .SH NAME unexpand \- convert spaces to tabs .SH SYNOPSIS .B unexpand [\-tab1[,tab2[,...]]] [\-t tab1[,tab2[,...]]] [\-a] [\-\-tabs=tab1[,tab2[,...]]] [\-\-all] [\-\-help] [\-\-version] [file...] .SH DESCRIPTION This manual page documents the GNU version of .BR unexpand . .B unexpand writes the contents of each given file, or the standard input if none are given or when a file named `\-' is given, to the standard output, with strings of two or more space or tab characters converted to as many tabs as possible followed by as many spaces as are needed. By default, .B unexpand converts only initial spaces and tabs (those that precede all non space or tab characters) on each line. It preserves backspace characters in the output; they decrement the column count for tab calculations. By default, tabs are set at every 8th column. .SS OPTIONS .TP .I "\-, \-t, \-\-tabs tab1[,tab2[,...]]" If only one tab stop is given, set the tabs \fItab1\fP spaces apart instead of the default 8. Otherwise, set the tabs at columns \fItab1\fP, \fItab2\fP, etc. (numbered from 0) and leave spaces and tabs beyond the tabstops given unchanged. If the tabstops are specified with the .I \-t or .I \-\-tabs option, they can be separated by blanks as well as by commas. This option implies the .I \-a option. .TP .I "\-a, \-\-all" Convert all strings of two or more spaces or tabs, not just initial ones, to tabs. .TP .I "\-\-help" Print a usage message and exit with a status code indicating success. .TP .I "\-\-version" Print version information on standard output then exit. textutils-1.12/man/uniq.1100666 74504 13 4367 5770034541 14414 0ustar meyeringuser.TH UNIQ 1L "GNU Text Utilities" "FSF" \" -*- nroff -*- .SH NAME uniq \- remove duplicate lines from a sorted file .SH SYNOPSIS .B uniq [\-cdu] [\-f skip-fields] [\-s skip-chars] [\-w check-chars] [\-#skip-fields] [+#skip-chars] [\-\-count] [\-\-repeated] [\-\-unique] [\-\-skip-fields=skip-fields] [\-\-skip-chars=skip-chars] [\-\-check-chars=check-chars] [\-\-help] [\-\-version] [infile] [outfile] .SH DESCRIPTION This manual page documents the GNU version of .BR uniq . .B uniq prints the unique lines in a sorted file, discarding all but one of a run of matching lines. It can optionally show only lines that appear exactly once, or lines that appear more than once. .B uniq requires sorted input because it compares only consecutive lines. .PP If the output file is not specified, .B uniq writes to the standard output. If the input file is not specified, it reads from the standard input. .SS OPTIONS .TP .I "\-u, \-\-unique" Only print unique lines. .TP .I "\-d, \-\-repeated" Only print duplicate lines. .TP .I "\-c, \-\-count" Print the number of times each line occurred along with the line. .TP .I "\-number, \-f, \-\-skip-fields=number" In this option, \fInumber\fP is an integer representing the number of fields to skip over before checking for uniqueness. The first \fInumber\fP fields, along with any blanks found before \fInumber\fP fields is reached, are skipped over and not counted. Fields are defined as a strings of non-space, non-tab characters, that are separated from each other by spaces and tabs. .TP .I "+number, \-s, \-\-skip-chars=number" In this option, \fInumber\fP is an integer representing the number of characters to skip over before checking for uniqueness. The first \fInumber\fP characters, along with any blanks found before \fInumber\fP characters is reached, are skipped over and not counted. If you use both the field and character skipping options, fields are skipped over first. .TP .I "\-w, \-\-check-chars=number" Specify the number of characters to compare in the lines, after skipping any specified fields and characters. Normally the entire rest of the lines are compared. .TP .I "\-\-help" Print a usage message and exit with a status code indicating success. .TP .I "\-\-version" Print version information on standard output then exit. textutils-1.12/man/wc.1100666 74504 13 2531 5770034541 14040 0ustar meyeringuser.TH WC 1L "GNU Text Utilities" "FSF" \" -*- nroff -*- .SH NAME wc \- print the number of bytes, words, and lines in files .SH SYNOPSIS .B wc [\-clw] [\-\-bytes] [\-\-chars] [\-\-lines] [\-\-words] [\-\-help] [\-\-version] [file...] .SH DESCRIPTION This manual page documents the GNU version of .BR wc . .B wc counts the number of bytes, whitespace-separated words, and newlines in each given file, or the standard input if none are given or when a file named `\-' is given. It prints one line of counts for each file, and if the file was given as an argument, it prints the filename following the counts. If more than one filename is given, .B wc prints a final line containing the cumulative counts, with the filename `total'. The counts are printed in the order: lines, words, bytes. .PP By default, .B wc prints all three counts. Options can specify that only certain counts be printed. Options do not undo others previously given, so .BI wc " \-\-bytes \-\-words" prints both the byte counts and the word counts. .SS OPTIONS .TP .I "\-c, \-\-bytes, \-\-chars" Print only the byte counts. .TP .I "\-w, \-\-words" Print only the word counts. .TP .I "\-l, \-\-lines" Print only the newline counts. .TP .I "\-\-help" Print a usage message and exit with a status code indicating success. .TP .I "\-\-version" Print version information on standard output then exit. textutils-1.12/doc/ 40777 74504 13 0 5771033606 13243 5ustar meyeringusertextutils-1.12/doc/Makefile.in100666 74504 13 5415 5770310747 15415 0ustar meyeringuser# Makefile for GNU text utilities documentation. # Copyright (C) 1994, 1995 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. SHELL = /bin/sh srcdir = @srcdir@ VPATH = @srcdir@ INSTALL = @INSTALL@ INSTALL_DATA = @INSTALL_DATA@ MAKEINFO = makeinfo TEXI2DVI = texi2dvi prefix = @prefix@ infodir = $(prefix)/info .SUFFIXES: DISTFILES = Makefile.in texinfo.tex textutils.texi textutils.info \ version.texi all: textutils.info info: textutils.info version.texi: ../src/version.c sed -e '/version_string/!d' \ -e 's/[^0-9.]*\([0-9.a-z]*\).*/@set VERSION \1/' \ -e q $(srcdir)/../src/version.c \ > $@-t echo '@set RELEASEDATE '`date '+%B %Y'` >> $@-t mv $@-t $@ textutils.info: textutils.texi version.texi $(MAKEINFO) -I$(srcdir) --no-split textutils.texi --output=$@ dvi: textutils.dvi textutils.dvi: textutils.texi version.texi texinfo.tex $(TEXI2DVI) $(srcdir)/textutils.texi installdirs: $(srcdir)/../mkinstalldirs $(infodir) install: install-exec install-data install-exec: install-data: all installdirs cd $(srcdir) && for file in textutils.info; do \ $(INSTALL_DATA) $$file $(infodir)/$$file; \ done uninstall: rm -f $(infodir)/textutils.info check: texclean: rm -f *.aux *.cp *.dvi *.fn *.ky *.log *.pg *.toc *.tp *.vr \ *.fl *.cm *.op *.cps mostlyclean: texclean clean: mostlyclean distclean: clean rm -f Makefile maintainer-clean: distclean @echo "This command is intended for use by maintainers;" @echo "it deletes files that may require special tools to rebuild." rm -f textutils.info version.texi distdir = ../`cat ../distname`/$(subdir) dist: $(DISTFILES) for file in $(DISTFILES); do \ ln $$file $(distdir) \ || { echo copying $$file instead; cp -p $$file $(distdir);}; \ done subdir = doc Makefile: ../config.status Makefile.in cd .. && CONFIG_FILES=$(subdir)/$@ CONFIG_HEADERS= ./config.status .PHONY: all check clean dist distclean dvi info install install-data \ install-exec installdirs maintainer-clean mostlyclean texclean uninstall # 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: textutils-1.12/doc/texinfo.tex100444 21623 13 435354 5737700071 14527 0ustar mibuser%% TeX macros to handle texinfo files % Copyright (C) 1985, 86, 88, 90, 91, 92, 93, 1994 Free Software Foundation, Inc. %This texinfo.tex file 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 texinfo.tex file 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 texinfo.tex file; see the file COPYING. If not, write %to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, %USA. %In other words, you are welcome to use, share and improve this program. %You are forbidden to forbid anyone else to use, share and improve %what you give them. Help stamp out software-hoarding! % Send bug reports to bug-texinfo@prep.ai.mit.edu. % Please include a *precise* test case in each bug report. % Make it possible to create a .fmt file just by loading this file: % if the underlying format is not loaded, start by loading it now. % Added by gildea November 1993. \expandafter\ifx\csname fmtname\endcsname\relax\input plain\fi % This automatically updates the version number based on RCS. \def\deftexinfoversion$#1: #2 ${\def\texinfoversion{#2}} \deftexinfoversion$Revision: 2.145 $ \message{Loading texinfo package [Version \texinfoversion]:} % If in a .fmt file, print the version number % and turn on active characters that we couldn't do earlier because % they might have appeared in the input file name. \everyjob{\message{[Texinfo version \texinfoversion]}\message{} \catcode`+=\active \catcode`\_=\active} % Save some parts of plain tex whose names we will redefine. \let\ptextilde=\~ \let\ptexlbrace=\{ \let\ptexrbrace=\} \let\ptexdots=\dots \let\ptexdot=\. \let\ptexstar=\* \let\ptexend=\end \let\ptexbullet=\bullet \let\ptexb=\b \let\ptexc=\c \let\ptexi=\i \let\ptext=\t \let\ptexl=\l \let\ptexL=\L % Be sure we're in horizontal mode when doing a tie, since we make space % equivalent to this in @example-like environments. Otherwise, a space % at the beginning of a line will start with \penalty -- and % since \penalty is valid in vertical mode, we'd end up putting the % penalty on the vertical list instead of in the new paragraph. {\catcode`@ = 11 \gdef\tie{\leavevmode\penalty\@M\ } } \let\~ = \tie % And make it available as @~. \message{Basics,} \chardef\other=12 % If this character appears in an error message or help string, it % starts a new line in the output. \newlinechar = `^^J % Set up fixed words for English. \ifx\putwordChapter\undefined{\gdef\putwordChapter{Chapter}}\fi% \def\putwordInfo{Info}% \ifx\putwordSee\undefined{\gdef\putwordSee{See}}\fi% \ifx\putwordsee\undefined{\gdef\putwordsee{see}}\fi% \ifx\putwordfile\undefined{\gdef\putwordfile{file}}\fi% \ifx\putwordpage\undefined{\gdef\putwordpage{page}}\fi% \ifx\putwordsection\undefined{\gdef\putwordsection{section}}\fi% \ifx\putwordSection\undefined{\gdef\putwordSection{Section}}\fi% \ifx\putwordTableofContents\undefined{\gdef\putwordTableofContents{Table of Contents}}\fi% \ifx\putwordShortContents\undefined{\gdef\putwordShortContents{Short Contents}}\fi% \ifx\putwordAppendix\undefined{\gdef\putwordAppendix{Appendix}}\fi% % Ignore a token. % \def\gobble#1{} \hyphenation{ap-pen-dix} \hyphenation{mini-buf-fer mini-buf-fers} \hyphenation{eshell} % Margin to add to right of even pages, to left of odd pages. \newdimen \bindingoffset \bindingoffset=0pt \newdimen \normaloffset \normaloffset=\hoffset \newdimen\pagewidth \newdimen\pageheight \pagewidth=\hsize \pageheight=\vsize % Sometimes it is convenient to have everything in the transcript file % and nothing on the terminal. We don't just call \tracingall here, % since that produces some useless output on the terminal. % \def\gloggingall{\begingroup \globaldefs = 1 \loggingall \endgroup}% \def\loggingall{\tracingcommands2 \tracingstats2 \tracingpages1 \tracingoutput1 \tracinglostchars1 \tracingmacros2 \tracingparagraphs1 \tracingrestores1 \showboxbreadth\maxdimen\showboxdepth\maxdimen }% %---------------------Begin change----------------------- % %%%% For @cropmarks command. % Dimensions to add cropmarks at corners Added by P. A. MacKay, 12 Nov. 1986 % \newdimen\cornerlong \newdimen\cornerthick \newdimen \topandbottommargin \newdimen \outerhsize \newdimen \outervsize \cornerlong=1pc\cornerthick=.3pt % These set size of cropmarks \outerhsize=7in %\outervsize=9.5in % Alternative @smallbook page size is 9.25in \outervsize=9.25in \topandbottommargin=.75in % %---------------------End change----------------------- % \onepageout takes a vbox as an argument. Note that \pagecontents % does insertions itself, but you have to call it yourself. \chardef\PAGE=255 \output={\onepageout{\pagecontents\PAGE}} \def\onepageout#1{\hoffset=\normaloffset \ifodd\pageno \advance\hoffset by \bindingoffset \else \advance\hoffset by -\bindingoffset\fi {\escapechar=`\\\relax % makes sure backslash is used in output files. \shipout\vbox{{\let\hsize=\pagewidth \makeheadline} \pagebody{#1}% {\let\hsize=\pagewidth \makefootline}}}% \advancepageno \ifnum\outputpenalty>-20000 \else\dosupereject\fi} %%%% For @cropmarks command %%%% % Here is a modification of the main output routine for Near East Publications % This provides right-angle cropmarks at all four corners. % The contents of the page are centerlined into the cropmarks, % and any desired binding offset is added as an \hskip on either % site of the centerlined box. (P. A. MacKay, 12 November, 1986) % \def\croppageout#1{\hoffset=0pt % make sure this doesn't mess things up {\escapechar=`\\\relax % makes sure backslash is used in output files. \shipout \vbox to \outervsize{\hsize=\outerhsize \vbox{\line{\ewtop\hfill\ewtop}} \nointerlineskip \line{\vbox{\moveleft\cornerthick\nstop} \hfill \vbox{\moveright\cornerthick\nstop}} \vskip \topandbottommargin \centerline{\ifodd\pageno\hskip\bindingoffset\fi \vbox{ {\let\hsize=\pagewidth \makeheadline} \pagebody{#1} {\let\hsize=\pagewidth \makefootline}} \ifodd\pageno\else\hskip\bindingoffset\fi} \vskip \topandbottommargin plus1fill minus1fill \boxmaxdepth\cornerthick \line{\vbox{\moveleft\cornerthick\nsbot} \hfill \vbox{\moveright\cornerthick\nsbot}} \nointerlineskip \vbox{\line{\ewbot\hfill\ewbot}} }} \advancepageno \ifnum\outputpenalty>-20000 \else\dosupereject\fi} % % Do @cropmarks to get crop marks \def\cropmarks{\let\onepageout=\croppageout } \newinsert\margin \dimen\margin=\maxdimen \def\pagebody#1{\vbox to\pageheight{\boxmaxdepth=\maxdepth #1}} {\catcode`\@ =11 \gdef\pagecontents#1{\ifvoid\topins\else\unvbox\topins\fi % marginal hacks, juha@viisa.uucp (Juha Takala) \ifvoid\margin\else % marginal info is present \rlap{\kern\hsize\vbox to\z@{\kern1pt\box\margin \vss}}\fi \dimen@=\dp#1 \unvbox#1 \ifvoid\footins\else\vskip\skip\footins\footnoterule \unvbox\footins\fi \ifr@ggedbottom \kern-\dimen@ \vfil \fi} } % % Here are the rules for the cropmarks. Note that they are % offset so that the space between them is truly \outerhsize or \outervsize % (P. A. MacKay, 12 November, 1986) % \def\ewtop{\vrule height\cornerthick depth0pt width\cornerlong} \def\nstop{\vbox {\hrule height\cornerthick depth\cornerlong width\cornerthick}} \def\ewbot{\vrule height0pt depth\cornerthick width\cornerlong} \def\nsbot{\vbox {\hrule height\cornerlong depth\cornerthick width\cornerthick}} % Parse an argument, then pass it to #1. The argument is the rest of % the input line (except we remove a trailing comment). #1 should be a % macro which expects an ordinary undelimited TeX argument. % \def\parsearg#1{% \let\next = #1% \begingroup \obeylines \futurelet\temp\parseargx } % If the next token is an obeyed space (from an @example environment or % the like), remove it and recurse. Otherwise, we're done. \def\parseargx{% % \obeyedspace is defined far below, after the definition of \sepspaces. \ifx\obeyedspace\temp \expandafter\parseargdiscardspace \else \expandafter\parseargline \fi } % Remove a single space (as the delimiter token to the macro call). {\obeyspaces % \gdef\parseargdiscardspace {\futurelet\temp\parseargx}} {\obeylines % \gdef\parseargline#1^^M{% \endgroup % End of the group started in \parsearg. % % First remove any @c comment, then any @comment. % Result of each macro is put in \toks0. \argremovec #1\c\relax % \expandafter\argremovecomment \the\toks0 \comment\relax % % % Call the caller's macro, saved as \next in \parsearg. \expandafter\next\expandafter{\the\toks0}% }% } % Since all \c{,omment} does is throw away the argument, we can let TeX % do that for us. The \relax here is matched by the \relax in the call % in \parseargline; it could be more or less anything, its purpose is % just to delimit the argument to the \c. \def\argremovec#1\c#2\relax{\toks0 = {#1}} \def\argremovecomment#1\comment#2\relax{\toks0 = {#1}} % \argremovec{,omment} might leave us with trailing spaces, though; e.g., % @end itemize @c foo % will have two active spaces as part of the argument with the % `itemize'. Here we remove all active spaces from #1, and assign the % result to \toks0. % % This loses if there are any *other* active characters besides spaces % in the argument -- _ ^ +, for example -- since they get expanded. % Fortunately, Texinfo does not define any such commands. (If it ever % does, the catcode of the characters in questionwill have to be changed % here.) But this means we cannot call \removeactivespaces as part of % \argremovec{,omment}, since @c uses \parsearg, and thus the argument % that \parsearg gets might well have any character at all in it. % \def\removeactivespaces#1{% \begingroup \ignoreactivespaces \edef\temp{#1}% \global\toks0 = \expandafter{\temp}% \endgroup } % Change the active space to expand to nothing. % \begingroup \obeyspaces \gdef\ignoreactivespaces{\obeyspaces\let =\empty} \endgroup \def\flushcr{\ifx\par\lisppar \def\next##1{}\else \let\next=\relax \fi \next} %% These are used to keep @begin/@end levels from running away %% Call \inENV within environments (after a \begingroup) \newif\ifENV \ENVfalse \def\inENV{\ifENV\relax\else\ENVtrue\fi} \def\ENVcheck{% \ifENV\errmessage{Still within an environment. Type Return to continue.} \endgroup\fi} % This is not perfect, but it should reduce lossage % @begin foo is the same as @foo, for now. \newhelp\EMsimple{Type to continue.} \outer\def\begin{\parsearg\beginxxx} \def\beginxxx #1{% \expandafter\ifx\csname #1\endcsname\relax {\errhelp=\EMsimple \errmessage{Undefined command @begin #1}}\else \csname #1\endcsname\fi} % @end foo executes the definition of \Efoo. % \def\end{\parsearg\endxxx} \def\endxxx #1{% \removeactivespaces{#1}% \edef\endthing{\the\toks0}% % \expandafter\ifx\csname E\endthing\endcsname\relax \expandafter\ifx\csname \endthing\endcsname\relax % There's no \foo, i.e., no ``environment'' foo. \errhelp = \EMsimple \errmessage{Undefined command `@end \endthing'}% \else \unmatchedenderror\endthing \fi \else % Everything's ok; the right environment has been started. \csname E\endthing\endcsname \fi } % There is an environment #1, but it hasn't been started. Give an error. % \def\unmatchedenderror#1{% \errhelp = \EMsimple \errmessage{This `@end #1' doesn't have a matching `@#1'}% } % Define the control sequence \E#1 to give an unmatched @end error. % \def\defineunmatchedend#1{% \expandafter\def\csname E#1\endcsname{\unmatchedenderror{#1}}% } % Single-spacing is done by various environments (specifically, in % \nonfillstart and \quotations). \newskip\singlespaceskip \singlespaceskip = 12.5pt \def\singlespace{% % Why was this kern here? It messes up equalizing space above and below % environments. --karl, 6may93 %{\advance \baselineskip by -\singlespaceskip %\kern \baselineskip}% \setleading \singlespaceskip } %% Simple single-character @ commands % @@ prints an @ % Kludge this until the fonts are right (grr). \def\@{{\tt \char '100}} % This is turned off because it was never documented % and you can use @w{...} around a quote to suppress ligatures. %% Define @` and @' to be the same as ` and ' %% but suppressing ligatures. %\def\`{{`}} %\def\'{{'}} % Used to generate quoted braces. \def\mylbrace {{\tt \char '173}} \def\myrbrace {{\tt \char '175}} \let\{=\mylbrace \let\}=\myrbrace % @: forces normal size whitespace following. \def\:{\spacefactor=1000 } % @* forces a line break. \def\*{\hfil\break\hbox{}\ignorespaces} % @. is an end-of-sentence period. \def\.{.\spacefactor=3000 } % @enddots{} is an end-of-sentence ellipsis. \gdef\enddots{$\mathinner{\ldotp\ldotp\ldotp\ldotp}$\spacefactor=3000} % @! is an end-of-sentence bang. \gdef\!{!\spacefactor=3000 } % @? is an end-of-sentence query. \gdef\?{?\spacefactor=3000 } % @w prevents a word break. Without the \leavevmode, @w at the % beginning of a paragraph, when TeX is still in vertical mode, would % produce a whole line of output instead of starting the paragraph. \def\w#1{\leavevmode\hbox{#1}} % @group ... @end group forces ... to be all on one page, by enclosing % it in a TeX vbox. We use \vtop instead of \vbox to construct the box % to keep its height that of a normal line. According to the rules for % \topskip (p.114 of the TeXbook), the glue inserted is % max (\topskip - \ht (first item), 0). If that height is large, % therefore, no glue is inserted, and the space between the headline and % the text is small, which looks bad. % \def\group{\begingroup \ifnum\catcode13=\active \else \errhelp = \groupinvalidhelp \errmessage{@group invalid in context where filling is enabled}% \fi % % The \vtop we start below produces a box with normal height and large % depth; thus, TeX puts \baselineskip glue before it, and (when the % next line of text is done) \lineskip glue after it. (See p.82 of % the TeXbook.) Thus, space below is not quite equal to space % above. But it's pretty close. \def\Egroup{% \egroup % End the \vtop. \endgroup % End the \group. }% % \vtop\bgroup % We have to put a strut on the last line in case the @group is in % the midst of an example, rather than completely enclosing it. % Otherwise, the interline space between the last line of the group % and the first line afterwards is too small. But we can't put the % strut in \Egroup, since there it would be on a line by itself. % Hence this just inserts a strut at the beginning of each line. \everypar = {\strut}% % % Since we have a strut on every line, we don't need any of TeX's % normal interline spacing. \offinterlineskip % % OK, but now we have to do something about blank % lines in the input in @example-like environments, which normally % just turn into \lisppar, which will insert no space now that we've % turned off the interline space. Simplest is to make them be an % empty paragraph. \ifx\par\lisppar \edef\par{\leavevmode \par}% % % Reset ^^M's definition to new definition of \par. \obeylines \fi % % Do @comment since we are called inside an environment such as % @example, where each end-of-line in the input causes an % end-of-line in the output. We don't want the end-of-line after % the `@group' to put extra space in the output. Since @group % should appear on a line by itself (according to the Texinfo % manual), we don't worry about eating any user text. \comment } % % TeX puts in an \escapechar (i.e., `@') at the beginning of the help % message, so this ends up printing `@group can only ...'. % \newhelp\groupinvalidhelp{% group can only be used in environments such as @example,^^J% where each line of input produces a line of output.} % @need space-in-mils % forces a page break if there is not space-in-mils remaining. \newdimen\mil \mil=0.001in \def\need{\parsearg\needx} % Old definition--didn't work. %\def\needx #1{\par % %% This method tries to make TeX break the page naturally %% if the depth of the box does not fit. %{\baselineskip=0pt% %\vtop to #1\mil{\vfil}\kern -#1\mil\penalty 10000 %\prevdepth=-1000pt %}} \def\needx#1{% % Go into vertical mode, so we don't make a big box in the middle of a % paragraph. \par % % Don't add any leading before our big empty box, but allow a page % break, since the best break might be right here. \allowbreak \nointerlineskip \vtop to #1\mil{\vfil}% % % TeX does not even consider page breaks if a penalty added to the % main vertical list is 10000 or more. But in order to see if the % empty box we just added fits on the page, we must make it consider % page breaks. On the other hand, we don't want to actually break the % page after the empty box. So we use a penalty of 9999. % % There is an extremely small chance that TeX will actually break the % page at this \penalty, if there are no other feasible breakpoints in % sight. (If the user is using lots of big @group commands, which % almost-but-not-quite fill up a page, TeX will have a hard time doing % good page breaking, for example.) However, I could not construct an % example where a page broke at this \penalty; if it happens in a real % document, then we can reconsider our strategy. \penalty9999 % % Back up by the size of the box, whether we did a page break or not. \kern -#1\mil % % Do not allow a page break right after this kern. \nobreak } % @br forces paragraph break \let\br = \par % @dots{} output some dots \def\dots{$\ldots$} % @page forces the start of a new page \def\page{\par\vfill\supereject} % @exdent text.... % outputs text on separate line in roman font, starting at standard page margin % This records the amount of indent in the innermost environment. % That's how much \exdent should take out. \newskip\exdentamount % This defn is used inside fill environments such as @defun. \def\exdent{\parsearg\exdentyyy} \def\exdentyyy #1{{\hfil\break\hbox{\kern -\exdentamount{\rm#1}}\hfil\break}} % This defn is used inside nofill environments such as @example. \def\nofillexdent{\parsearg\nofillexdentyyy} \def\nofillexdentyyy #1{{\advance \leftskip by -\exdentamount \leftline{\hskip\leftskip{\rm#1}}}} %\hbox{{\rm#1}}\hfil\break}} % @include file insert text of that file as input. \def\include{\parsearg\includezzz} %Use \input\thisfile to avoid blank after \input, which may be an active %char (in which case the blank would become the \input argument). %The grouping keeps the value of \thisfile correct even when @include %is nested. \def\includezzz #1{\begingroup \def\thisfile{#1}\input\thisfile \endgroup} \def\thisfile{} % @center line outputs that line, centered \def\center{\parsearg\centerzzz} \def\centerzzz #1{{\advance\hsize by -\leftskip \advance\hsize by -\rightskip \centerline{#1}}} % @sp n outputs n lines of vertical space \def\sp{\parsearg\spxxx} \def\spxxx #1{\par \vskip #1\baselineskip} % @comment ...line which is ignored... % @c is the same as @comment % @ignore ... @end ignore is another way to write a comment \def\comment{\catcode 64=\other \catcode 123=\other \catcode 125=\other% \parsearg \commentxxx} \def\commentxxx #1{\catcode 64=0 \catcode 123=1 \catcode 125=2 } \let\c=\comment % Prevent errors for section commands. % Used in @ignore and in failing conditionals. \def\ignoresections{% \let\chapter=\relax \let\unnumbered=\relax \let\top=\relax \let\unnumberedsec=\relax \let\unnumberedsection=\relax \let\unnumberedsubsec=\relax \let\unnumberedsubsection=\relax \let\unnumberedsubsubsec=\relax \let\unnumberedsubsubsection=\relax \let\section=\relax \let\subsec=\relax \let\subsubsec=\relax \let\subsection=\relax \let\subsubsection=\relax \let\appendix=\relax \let\appendixsec=\relax \let\appendixsection=\relax \let\appendixsubsec=\relax \let\appendixsubsection=\relax \let\appendixsubsubsec=\relax \let\appendixsubsubsection=\relax \let\contents=\relax \let\smallbook=\relax \let\titlepage=\relax } % Used in nested conditionals, where we have to parse the Texinfo source % and so want to turn off most commands, in case they are used % incorrectly. % \def\ignoremorecommands{% \let\defcv = \relax \let\deffn = \relax \let\deffnx = \relax \let\defindex = \relax \let\defivar = \relax \let\defmac = \relax \let\defmethod = \relax \let\defop = \relax \let\defopt = \relax \let\defspec = \relax \let\deftp = \relax \let\deftypefn = \relax \let\deftypefun = \relax \let\deftypevar = \relax \let\deftypevr = \relax \let\defun = \relax \let\defvar = \relax \let\defvr = \relax \let\ref = \relax \let\xref = \relax \let\printindex = \relax \let\pxref = \relax \let\settitle = \relax \let\include = \relax \let\lowersections = \relax \let\down = \relax \let\raisesections = \relax \let\up = \relax \let\set = \relax \let\clear = \relax \let\item = \relax \let\message = \relax } % Ignore @ignore ... @end ignore. % \def\ignore{\doignore{ignore}} % Also ignore @ifinfo, @ifhtml, @html, @menu, and @direntry text. % \def\ifinfo{\doignore{ifinfo}} \def\ifhtml{\doignore{ifhtml}} \def\html{\doignore{html}} \def\menu{\doignore{menu}} \def\direntry{\doignore{direntry}} % Ignore text until a line `@end #1'. % \def\doignore#1{\begingroup % Don't complain about control sequences we have declared \outer. \ignoresections % % Define a command to swallow text until we reach `@end #1'. \long\def\doignoretext##1\end #1{\enddoignore}% % % Make sure that spaces turn into tokens that match what \doignoretext wants. \catcode32 = 10 % % And now expand that command. \doignoretext } % What we do to finish off ignored text. % \def\enddoignore{\endgroup\ignorespaces}% \newif\ifwarnedobs\warnedobsfalse \def\obstexwarn{% \ifwarnedobs\relax\else % We need to warn folks that they may have trouble with TeX 3.0. % This uses \immediate\write16 rather than \message to get newlines. \immediate\write16{} \immediate\write16{***WARNING*** for users of Unix TeX 3.0!} \immediate\write16{This manual trips a bug in TeX version 3.0 (tex hangs).} \immediate\write16{If you are running another version of TeX, relax.} \immediate\write16{If you are running Unix TeX 3.0, kill this TeX process.} \immediate\write16{ Then upgrade your TeX installation if you can.} \immediate\write16{If you are stuck with version 3.0, run the} \immediate\write16{ script ``tex3patch'' from the Texinfo distribution} \immediate\write16{ to use a workaround.} \immediate\write16{} \warnedobstrue \fi } % **In TeX 3.0, setting text in \nullfont hangs tex. For a % workaround (which requires the file ``dummy.tfm'' to be installed), % uncomment the following line: %%%%%\font\nullfont=dummy\let\obstexwarn=\relax % Ignore text, except that we keep track of conditional commands for % purposes of nesting, up to an `@end #1' command. % \def\nestedignore#1{% \obstexwarn % We must actually expand the ignored text to look for the @end % command, so that nested ignore constructs work. Thus, we put the % text into a \vbox and then do nothing with the result. To minimize % the change of memory overflow, we follow the approach outlined on % page 401 of the TeXbook: make the current font be a dummy font. % \setbox0 = \vbox\bgroup % Don't complain about control sequences we have declared \outer. \ignoresections % % Define `@end #1' to end the box, which will in turn undefine the % @end command again. \expandafter\def\csname E#1\endcsname{\egroup\ignorespaces}% % % We are going to be parsing Texinfo commands. Most cause no % trouble when they are used incorrectly, but some commands do % complicated argument parsing or otherwise get confused, so we % undefine them. % % We can't do anything about stray @-signs, unfortunately; % they'll produce `undefined control sequence' errors. \ignoremorecommands % % Set the current font to be \nullfont, a TeX primitive, and define % all the font commands to also use \nullfont. We don't use % dummy.tfm, as suggested in the TeXbook, because not all sites % might have that installed. Therefore, math mode will still % produce output, but that should be an extremely small amount of % stuff compared to the main input. % \nullfont \let\tenrm = \nullfont \let\tenit = \nullfont \let\tensl = \nullfont \let\tenbf = \nullfont \let\tentt = \nullfont \let\smallcaps = \nullfont \let\tensf = \nullfont % Similarly for index fonts (mostly for their use in % smallexample) \let\indrm = \nullfont \let\indit = \nullfont \let\indsl = \nullfont \let\indbf = \nullfont \let\indtt = \nullfont \let\indsc = \nullfont \let\indsf = \nullfont % % Don't complain when characters are missing from the fonts. \tracinglostchars = 0 % % Don't bother to do space factor calculations. \frenchspacing % % Don't report underfull hboxes. \hbadness = 10000 % % Do minimal line-breaking. \pretolerance = 10000 % % Do not execute instructions in @tex \def\tex{\doignore{tex}} } % @set VAR sets the variable VAR to an empty value. % @set VAR REST-OF-LINE sets VAR to the value REST-OF-LINE. % % Since we want to separate VAR from REST-OF-LINE (which might be % empty), we can't just use \parsearg; we have to insert a space of our % own to delimit the rest of the line, and then take it out again if we % didn't need it. % \def\set{\parsearg\setxxx} \def\setxxx#1{\setyyy#1 \endsetyyy} \def\setyyy#1 #2\endsetyyy{% \def\temp{#2}% \ifx\temp\empty \global\expandafter\let\csname SET#1\endcsname = \empty \else \setzzz{#1}#2\endsetzzz % Remove the trailing space \setxxx inserted. \fi } % Can't use \xdef to pre-expand #2 and save some time, since \temp or % \next or other control sequences that we've defined might get us into % an infinite loop. Consider `@set foo @cite{bar}'. \def\setzzz#1#2 \endsetzzz{\expandafter\gdef\csname SET#1\endcsname{#2}} % @clear VAR clears (i.e., unsets) the variable VAR. % \def\clear{\parsearg\clearxxx} \def\clearxxx#1{\global\expandafter\let\csname SET#1\endcsname=\relax} % @value{foo} gets the text saved in variable foo. % \def\value#1{\expandafter \ifx\csname SET#1\endcsname\relax {\{No value for ``#1''\}} \else \csname SET#1\endcsname \fi} % @ifset VAR ... @end ifset reads the `...' iff VAR has been defined % with @set. % \def\ifset{\parsearg\ifsetxxx} \def\ifsetxxx #1{% \expandafter\ifx\csname SET#1\endcsname\relax \expandafter\ifsetfail \else \expandafter\ifsetsucceed \fi } \def\ifsetsucceed{\conditionalsucceed{ifset}} \def\ifsetfail{\nestedignore{ifset}} \defineunmatchedend{ifset} % @ifclear VAR ... @end ifclear reads the `...' iff VAR has never been % defined with @set, or has been undefined with @clear. % \def\ifclear{\parsearg\ifclearxxx} \def\ifclearxxx #1{% \expandafter\ifx\csname SET#1\endcsname\relax \expandafter\ifclearsucceed \else \expandafter\ifclearfail \fi } \def\ifclearsucceed{\conditionalsucceed{ifclear}} \def\ifclearfail{\nestedignore{ifclear}} \defineunmatchedend{ifclear} % @iftex always succeeds; we read the text following, through @end % iftex). But `@end iftex' should be valid only after an @iftex. % \def\iftex{\conditionalsucceed{iftex}} \defineunmatchedend{iftex} % We can't just want to start a group at @iftex (for example) and end it % at @end iftex, since then @set commands inside the conditional have no % effect (they'd get reverted at the end of the group). So we must % define \Eiftex to redefine itself to be its previous value. (We can't % just define it to fail again with an ``unmatched end'' error, since % the @ifset might be nested.) % \def\conditionalsucceed#1{% \edef\temp{% % Remember the current value of \E#1. \let\nece{prevE#1} = \nece{E#1}% % % At the `@end #1', redefine \E#1 to be its previous value. \def\nece{E#1}{\let\nece{E#1} = \nece{prevE#1}}% }% \temp } % We need to expand lots of \csname's, but we don't want to expand the % control sequences after we've constructed them. % \def\nece#1{\expandafter\noexpand\csname#1\endcsname} % @asis just yields its argument. Used with @table, for example. % \def\asis#1{#1} % @math means output in math mode. % We don't use $'s directly in the definition of \math because control % sequences like \math are expanded when the toc file is written. Then, % we read the toc file back, the $'s will be normal characters (as they % should be, according to the definition of Texinfo). So we must use a % control sequence to switch into and out of math mode. % % This isn't quite enough for @math to work properly in indices, but it % seems unlikely it will ever be needed there. % \let\implicitmath = $ \def\math#1{\implicitmath #1\implicitmath} % @bullet and @minus need the same treatment as @math, just above. \def\bullet{\implicitmath\ptexbullet\implicitmath} \def\minus{\implicitmath-\implicitmath} \def\node{\ENVcheck\parsearg\nodezzz} \def\nodezzz#1{\nodexxx [#1,]} \def\nodexxx[#1,#2]{\gdef\lastnode{#1}} \let\nwnode=\node \let\lastnode=\relax \def\donoderef{\ifx\lastnode\relax\else \expandafter\expandafter\expandafter\setref{\lastnode}\fi \global\let\lastnode=\relax} \def\unnumbnoderef{\ifx\lastnode\relax\else \expandafter\expandafter\expandafter\unnumbsetref{\lastnode}\fi \global\let\lastnode=\relax} \def\appendixnoderef{\ifx\lastnode\relax\else \expandafter\expandafter\expandafter\appendixsetref{\lastnode}\fi \global\let\lastnode=\relax} \let\refill=\relax % @setfilename is done at the beginning of every texinfo file. % So open here the files we need to have open while reading the input. % This makes it possible to make a .fmt file for texinfo. \def\setfilename{% \readauxfile \opencontents \openindices \fixbackslash % Turn off hack to swallow `\input texinfo'. \global\let\setfilename=\comment % Ignore extra @setfilename cmds. \comment % Ignore the actual filename. } \outer\def\bye{\pagealignmacro\tracingstats=1\ptexend} \def\inforef #1{\inforefzzz #1,,,,**} \def\inforefzzz #1,#2,#3,#4**{\putwordSee{} \putwordInfo{} \putwordfile{} \file{\ignorespaces #3{}}, node \samp{\ignorespaces#1{}}} \message{fonts,} % Font-change commands. % Texinfo supports the sans serif font style, which plain TeX does not. % So we set up a \sf analogous to plain's \rm, etc. \newfam\sffam \def\sf{\fam=\sffam \tensf} \let\li = \sf % Sometimes we call it \li, not \sf. %% Try out Computer Modern fonts at \magstephalf \let\mainmagstep=\magstephalf % Set the font macro #1 to the font named #2, adding on the % specified font prefix (normally `cm'). \def\setfont#1#2{\font#1=\fontprefix#2} % Use cm as the default font prefix. % To specify the font prefix, you must define \fontprefix % before you read in texinfo.tex. \ifx\fontprefix\undefined \def\fontprefix{cm} \fi \ifx\bigger\relax \let\mainmagstep=\magstep1 \setfont\textrm{r12} \setfont\texttt{tt12} \else \setfont\textrm{r10 scaled \mainmagstep} \setfont\texttt{tt10 scaled \mainmagstep} \fi % Instead of cmb10, you many want to use cmbx10. % cmbx10 is a prettier font on its own, but cmb10 % looks better when embedded in a line with cmr10. \setfont\textbf{b10 scaled \mainmagstep} \setfont\textit{ti10 scaled \mainmagstep} \setfont\textsl{sl10 scaled \mainmagstep} \setfont\textsf{ss10 scaled \mainmagstep} \setfont\textsc{csc10 scaled \mainmagstep} \font\texti=cmmi10 scaled \mainmagstep \font\textsy=cmsy10 scaled \mainmagstep % A few fonts for @defun, etc. \setfont\defbf{bx10 scaled \magstep1} %was 1314 \setfont\deftt{tt10 scaled \magstep1} \def\df{\let\tentt=\deftt \let\tenbf = \defbf \bf} % Fonts for indices and small examples. % We actually use the slanted font rather than the italic, % because texinfo normally uses the slanted fonts for that. % Do not make many font distinctions in general in the index, since they % aren't very useful. \setfont\ninett{tt9} \setfont\indrm{r9} \setfont\indit{sl9} \let\indsl=\indit \let\indtt=\ninett \let\indsf=\indrm \let\indbf=\indrm \setfont\indsc{csc10 at 9pt} \font\indi=cmmi9 \font\indsy=cmsy9 % Fonts for headings \setfont\chaprm{bx12 scaled \magstep2} \setfont\chapit{ti12 scaled \magstep2} \setfont\chapsl{sl12 scaled \magstep2} \setfont\chaptt{tt12 scaled \magstep2} \setfont\chapsf{ss12 scaled \magstep2} \let\chapbf=\chaprm \setfont\chapsc{csc10 scaled\magstep3} \font\chapi=cmmi12 scaled \magstep2 \font\chapsy=cmsy10 scaled \magstep3 \setfont\secrm{bx12 scaled \magstep1} \setfont\secit{ti12 scaled \magstep1} \setfont\secsl{sl12 scaled \magstep1} \setfont\sectt{tt12 scaled \magstep1} \setfont\secsf{ss12 scaled \magstep1} \setfont\secbf{bx12 scaled \magstep1} \setfont\secsc{csc10 scaled\magstep2} \font\seci=cmmi12 scaled \magstep1 \font\secsy=cmsy10 scaled \magstep2 % \setfont\ssecrm{bx10 scaled \magstep1} % This size an font looked bad. % \setfont\ssecit{cmti10 scaled \magstep1} % The letters were too crowded. % \setfont\ssecsl{sl10 scaled \magstep1} % \setfont\ssectt{tt10 scaled \magstep1} % \setfont\ssecsf{ss10 scaled \magstep1} %\setfont\ssecrm{b10 scaled 1315} % Note the use of cmb rather than cmbx. %\setfont\ssecit{ti10 scaled 1315} % Also, the size is a little larger than %\setfont\ssecsl{sl10 scaled 1315} % being scaled magstep1. %\setfont\ssectt{tt10 scaled 1315} %\setfont\ssecsf{ss10 scaled 1315} %\let\ssecbf=\ssecrm \setfont\ssecrm{bx12 scaled \magstephalf} \setfont\ssecit{ti12 scaled \magstephalf} \setfont\ssecsl{sl12 scaled \magstephalf} \setfont\ssectt{tt12 scaled \magstephalf} \setfont\ssecsf{ss12 scaled \magstephalf} \setfont\ssecbf{bx12 scaled \magstephalf} \setfont\ssecsc{csc10 scaled \magstep1} \font\sseci=cmmi12 scaled \magstephalf \font\ssecsy=cmsy10 scaled \magstep1 % The smallcaps and symbol fonts should actually be scaled \magstep1.5, % but that is not a standard magnification. % Fonts for title page: \setfont\titlerm{bx12 scaled \magstep3} \let\authorrm = \secrm % In order for the font changes to affect most math symbols and letters, % we have to define the \textfont of the standard families. Since % texinfo doesn't allow for producing subscripts and superscripts, we % don't bother to reset \scriptfont and \scriptscriptfont (which would % also require loading a lot more fonts). % \def\resetmathfonts{% \textfont0 = \tenrm \textfont1 = \teni \textfont2 = \tensy \textfont\itfam = \tenit \textfont\slfam = \tensl \textfont\bffam = \tenbf \textfont\ttfam = \tentt \textfont\sffam = \tensf } % The font-changing commands redefine the meanings of \tenSTYLE, instead % of just \STYLE. We do this so that font changes will continue to work % in math mode, where it is the current \fam that is relevant in most % cases, not the current. Plain TeX does, for example, % \def\bf{\fam=\bffam \tenbf} By redefining \tenbf, we obviate the need % to redefine \bf itself. \def\textfonts{% \let\tenrm=\textrm \let\tenit=\textit \let\tensl=\textsl \let\tenbf=\textbf \let\tentt=\texttt \let\smallcaps=\textsc \let\tensf=\textsf \let\teni=\texti \let\tensy=\textsy \resetmathfonts} \def\chapfonts{% \let\tenrm=\chaprm \let\tenit=\chapit \let\tensl=\chapsl \let\tenbf=\chapbf \let\tentt=\chaptt \let\smallcaps=\chapsc \let\tensf=\chapsf \let\teni=\chapi \let\tensy=\chapsy \resetmathfonts} \def\secfonts{% \let\tenrm=\secrm \let\tenit=\secit \let\tensl=\secsl \let\tenbf=\secbf \let\tentt=\sectt \let\smallcaps=\secsc \let\tensf=\secsf \let\teni=\seci \let\tensy=\secsy \resetmathfonts} \def\subsecfonts{% \let\tenrm=\ssecrm \let\tenit=\ssecit \let\tensl=\ssecsl \let\tenbf=\ssecbf \let\tentt=\ssectt \let\smallcaps=\ssecsc \let\tensf=\ssecsf \let\teni=\sseci \let\tensy=\ssecsy \resetmathfonts} \def\indexfonts{% \let\tenrm=\indrm \let\tenit=\indit \let\tensl=\indsl \let\tenbf=\indbf \let\tentt=\indtt \let\smallcaps=\indsc \let\tensf=\indsf \let\teni=\indi \let\tensy=\indsy \resetmathfonts} % Set up the default fonts, so we can use them for creating boxes. % \textfonts % Count depth in font-changes, for error checks \newcount\fontdepth \fontdepth=0 % Fonts for short table of contents. \setfont\shortcontrm{r12} \setfont\shortcontbf{bx12} \setfont\shortcontsl{sl12} %% Add scribe-like font environments, plus @l for inline lisp (usually sans %% serif) and @ii for TeX italic % \smartitalic{ARG} outputs arg in italics, followed by an italic correction % unless the following character is such as not to need one. \def\smartitalicx{\ifx\next,\else\ifx\next-\else\ifx\next.\else\/\fi\fi\fi} \def\smartitalic#1{{\sl #1}\futurelet\next\smartitalicx} \let\i=\smartitalic \let\var=\smartitalic \let\dfn=\smartitalic \let\emph=\smartitalic \let\cite=\smartitalic \def\b#1{{\bf #1}} \let\strong=\b % We can't just use \exhyphenpenalty, because that only has effect at % the end of a paragraph. Restore normal hyphenation at the end of the % group within which \nohyphenation is presumably called. % \def\nohyphenation{\hyphenchar\font = -1 \aftergroup\restorehyphenation} \def\restorehyphenation{\hyphenchar\font = `- } \def\t#1{% {\tt \nohyphenation \rawbackslash \frenchspacing #1}% \null } \let\ttfont = \t %\def\samp #1{`{\tt \rawbackslash \frenchspacing #1}'\null} \def\samp #1{`\tclose{#1}'\null} \def\key #1{{\tt \nohyphenation \uppercase{#1}}\null} \def\ctrl #1{{\tt \rawbackslash \hat}#1} \let\file=\samp % @code is a modification of @t, % which makes spaces the same size as normal in the surrounding text. \def\tclose#1{% {% % Change normal interword space to be same as for the current font. \spaceskip = \fontdimen2\font % % Switch to typewriter. \tt % % But `\ ' produces the large typewriter interword space. \def\ {{\spaceskip = 0pt{} }}% % % Turn off hyphenation. \nohyphenation % \rawbackslash \frenchspacing #1% }% \null } % We *must* turn on hyphenation at `-' and `_' in \code. % Otherwise, it is too hard to avoid overful hboxes % in the Emacs manual, the Library manual, etc. % Unfortunately, TeX uses one parameter (\hyphenchar) to control % both hyphenation at - and hyphenation within words. % We must therefore turn them both off (\tclose does that) % and arrange explicitly to hyphenate an a dash. % -- rms. { \catcode`\-=\active \catcode`\_=\active \global\def\code{\begingroup \catcode`\-=\active \let-\codedash \catcode`\_=\active \let_\codeunder \codex} % The following is used by \doprintindex to insure that long function names % wrap around. It is necessary for - and _ to be active before the index is % read from the file, as \entry parses the arguments long before \code is % ever called. -- mycroft \global\def\indexbreaks{\catcode`\-=\active \let-\realdash \catcode`\_=\active \let_\realunder} } \def\realdash{-} \def\realunder{_} \def\codedash{-\discretionary{}{}{}} \def\codeunder{\normalunderscore\discretionary{}{}{}} \def\codex #1{\tclose{#1}\endgroup} %\let\exp=\tclose %Was temporary % @kbd is like @code, except that if the argument is just one @key command, % then @kbd has no effect. \def\xkey{\key} \def\kbdfoo#1#2#3\par{\def\one{#1}\def\three{#3}\def\threex{??}% \ifx\one\xkey\ifx\threex\three \key{#2}% \else\tclose{\look}\fi \else\tclose{\look}\fi} % Typeset a dimension, e.g., `in' or `pt'. The only reason for the % argument is to make the input look right: @dmn{pt} instead of % @dmn{}pt. % \def\dmn#1{\thinspace #1} \def\kbd#1{\def\look{#1}\expandafter\kbdfoo\look??\par} \def\l#1{{\li #1}\null} % \def\r#1{{\rm #1}} % roman font % Use of \lowercase was suggested. \def\sc#1{{\smallcaps#1}} % smallcaps font \def\ii#1{{\it #1}} % italic font \message{page headings,} \newskip\titlepagetopglue \titlepagetopglue = 1.5in \newskip\titlepagebottomglue \titlepagebottomglue = 2pc % First the title page. Must do @settitle before @titlepage. \def\titlefont#1{{\titlerm #1}} \newif\ifseenauthor \newif\iffinishedtitlepage \def\shorttitlepage{\parsearg\shorttitlepagezzz} \def\shorttitlepagezzz #1{\begingroup\hbox{}\vskip 1.5in \chaprm \centerline{#1}% \endgroup\page\hbox{}\page} \def\titlepage{\begingroup \parindent=0pt \textfonts \let\subtitlerm=\tenrm % I deinstalled the following change because \cmr12 is undefined. % This change was not in the ChangeLog anyway. --rms. % \let\subtitlerm=\cmr12 \def\subtitlefont{\subtitlerm \normalbaselineskip = 13pt \normalbaselines}% % \def\authorfont{\authorrm \normalbaselineskip = 16pt \normalbaselines}% % % Leave some space at the very top of the page. \vglue\titlepagetopglue % % Now you can print the title using @title. \def\title{\parsearg\titlezzz}% \def\titlezzz##1{\leftline{\titlefont{##1}} % print a rule at the page bottom also. \finishedtitlepagefalse \vskip4pt \hrule height 4pt width \hsize \vskip4pt}% % No rule at page bottom unless we print one at the top with @title. \finishedtitlepagetrue % % Now you can put text using @subtitle. \def\subtitle{\parsearg\subtitlezzz}% \def\subtitlezzz##1{{\subtitlefont \rightline{##1}}}% % % @author should come last, but may come many times. \def\author{\parsearg\authorzzz}% \def\authorzzz##1{\ifseenauthor\else\vskip 0pt plus 1filll\seenauthortrue\fi {\authorfont \leftline{##1}}}% % % Most title ``pages'' are actually two pages long, with space % at the top of the second. We don't want the ragged left on the second. \let\oldpage = \page \def\page{% \iffinishedtitlepage\else \finishtitlepage \fi \oldpage \let\page = \oldpage \hbox{}}% % \def\page{\oldpage \hbox{}} } \def\Etitlepage{% \iffinishedtitlepage\else \finishtitlepage \fi % It is important to do the page break before ending the group, % because the headline and footline are only empty inside the group. % If we use the new definition of \page, we always get a blank page % after the title page, which we certainly don't want. \oldpage \endgroup \HEADINGSon } \def\finishtitlepage{% \vskip4pt \hrule height 2pt width \hsize \vskip\titlepagebottomglue \finishedtitlepagetrue } %%% Set up page headings and footings. \let\thispage=\folio \newtoks \evenheadline % Token sequence for heading line of even pages \newtoks \oddheadline % Token sequence for heading line of odd pages \newtoks \evenfootline % Token sequence for footing line of even pages \newtoks \oddfootline % Token sequence for footing line of odd pages % Now make Tex use those variables \headline={{\textfonts\rm \ifodd\pageno \the\oddheadline \else \the\evenheadline \fi}} \footline={{\textfonts\rm \ifodd\pageno \the\oddfootline \else \the\evenfootline \fi}\HEADINGShook} \let\HEADINGShook=\relax % Commands to set those variables. % For example, this is what @headings on does % @evenheading @thistitle|@thispage|@thischapter % @oddheading @thischapter|@thispage|@thistitle % @evenfooting @thisfile|| % @oddfooting ||@thisfile \def\evenheading{\parsearg\evenheadingxxx} \def\oddheading{\parsearg\oddheadingxxx} \def\everyheading{\parsearg\everyheadingxxx} \def\evenfooting{\parsearg\evenfootingxxx} \def\oddfooting{\parsearg\oddfootingxxx} \def\everyfooting{\parsearg\everyfootingxxx} {\catcode`\@=0 % \gdef\evenheadingxxx #1{\evenheadingyyy #1@|@|@|@|\finish} \gdef\evenheadingyyy #1@|#2@|#3@|#4\finish{% \global\evenheadline={\rlap{\centerline{#2}}\line{#1\hfil#3}}} \gdef\oddheadingxxx #1{\oddheadingyyy #1@|@|@|@|\finish} \gdef\oddheadingyyy #1@|#2@|#3@|#4\finish{% \global\oddheadline={\rlap{\centerline{#2}}\line{#1\hfil#3}}} \gdef\everyheadingxxx #1{\everyheadingyyy #1@|@|@|@|\finish} \gdef\everyheadingyyy #1@|#2@|#3@|#4\finish{% \global\evenheadline={\rlap{\centerline{#2}}\line{#1\hfil#3}} \global\oddheadline={\rlap{\centerline{#2}}\line{#1\hfil#3}}} \gdef\evenfootingxxx #1{\evenfootingyyy #1@|@|@|@|\finish} \gdef\evenfootingyyy #1@|#2@|#3@|#4\finish{% \global\evenfootline={\rlap{\centerline{#2}}\line{#1\hfil#3}}} \gdef\oddfootingxxx #1{\oddfootingyyy #1@|@|@|@|\finish} \gdef\oddfootingyyy #1@|#2@|#3@|#4\finish{% \global\oddfootline={\rlap{\centerline{#2}}\line{#1\hfil#3}}} \gdef\everyfootingxxx #1{\everyfootingyyy #1@|@|@|@|\finish} \gdef\everyfootingyyy #1@|#2@|#3@|#4\finish{% \global\evenfootline={\rlap{\centerline{#2}}\line{#1\hfil#3}} \global\oddfootline={\rlap{\centerline{#2}}\line{#1\hfil#3}}} % }% unbind the catcode of @. % @headings double turns headings on for double-sided printing. % @headings single turns headings on for single-sided printing. % @headings off turns them off. % @headings on same as @headings double, retained for compatibility. % @headings after turns on double-sided headings after this page. % @headings doubleafter turns on double-sided headings after this page. % @headings singleafter turns on single-sided headings after this page. % By default, they are off. \def\headings #1 {\csname HEADINGS#1\endcsname} \def\HEADINGSoff{ \global\evenheadline={\hfil} \global\evenfootline={\hfil} \global\oddheadline={\hfil} \global\oddfootline={\hfil}} \HEADINGSoff % When we turn headings on, set the page number to 1. % For double-sided printing, put current file name in lower left corner, % chapter name on inside top of right hand pages, document % title on inside top of left hand pages, and page numbers on outside top % edge of all pages. \def\HEADINGSdouble{ %\pagealignmacro \global\pageno=1 \global\evenfootline={\hfil} \global\oddfootline={\hfil} \global\evenheadline={\line{\folio\hfil\thistitle}} \global\oddheadline={\line{\thischapter\hfil\folio}} } % For single-sided printing, chapter title goes across top left of page, % page number on top right. \def\HEADINGSsingle{ %\pagealignmacro \global\pageno=1 \global\evenfootline={\hfil} \global\oddfootline={\hfil} \global\evenheadline={\line{\thischapter\hfil\folio}} \global\oddheadline={\line{\thischapter\hfil\folio}} } \def\HEADINGSon{\HEADINGSdouble} \def\HEADINGSafter{\let\HEADINGShook=\HEADINGSdoublex} \let\HEADINGSdoubleafter=\HEADINGSafter \def\HEADINGSdoublex{% \global\evenfootline={\hfil} \global\oddfootline={\hfil} \global\evenheadline={\line{\folio\hfil\thistitle}} \global\oddheadline={\line{\thischapter\hfil\folio}} } \def\HEADINGSsingleafter{\let\HEADINGShook=\HEADINGSsinglex} \def\HEADINGSsinglex{% \global\evenfootline={\hfil} \global\oddfootline={\hfil} \global\evenheadline={\line{\thischapter\hfil\folio}} \global\oddheadline={\line{\thischapter\hfil\folio}} } % Subroutines used in generating headings % Produces Day Month Year style of output. \def\today{\number\day\space \ifcase\month\or January\or February\or March\or April\or May\or June\or July\or August\or September\or October\or November\or December\fi \space\number\year} % Use this if you want the Month Day, Year style of output. %\def\today{\ifcase\month\or %January\or February\or March\or April\or May\or June\or %July\or August\or September\or October\or November\or December\fi %\space\number\day, \number\year} % @settitle line... specifies the title of the document, for headings % It generates no output of its own \def\thistitle{No Title} \def\settitle{\parsearg\settitlezzz} \def\settitlezzz #1{\gdef\thistitle{#1}} \message{tables,} % @tabs -- simple alignment % These don't work. For one thing, \+ is defined as outer. % So these macros cannot even be defined. %\def\tabs{\parsearg\tabszzz} %\def\tabszzz #1{\settabs\+#1\cr} %\def\tabline{\parsearg\tablinezzz} %\def\tablinezzz #1{\+#1\cr} %\def\&{&} % Tables -- @table, @ftable, @vtable, @item(x), @kitem(x), @xitem(x). % default indentation of table text \newdimen\tableindent \tableindent=.8in % default indentation of @itemize and @enumerate text \newdimen\itemindent \itemindent=.3in % margin between end of table item and start of table text. \newdimen\itemmargin \itemmargin=.1in % used internally for \itemindent minus \itemmargin \newdimen\itemmax % Note @table, @vtable, and @vtable define @item, @itemx, etc., with % these defs. % They also define \itemindex % to index the item name in whatever manner is desired (perhaps none). \newif\ifitemxneedsnegativevskip \def\itemxpar{\par\ifitemxneedsnegativevskip\vskip-\parskip\nobreak\fi} \def\internalBitem{\smallbreak \parsearg\itemzzz} \def\internalBitemx{\itemxpar \parsearg\itemzzz} \def\internalBxitem "#1"{\def\xitemsubtopix{#1} \smallbreak \parsearg\xitemzzz} \def\internalBxitemx "#1"{\def\xitemsubtopix{#1} \itemxpar \parsearg\xitemzzz} \def\internalBkitem{\smallbreak \parsearg\kitemzzz} \def\internalBkitemx{\itemxpar \parsearg\kitemzzz} \def\kitemzzz #1{\dosubind {kw}{\code{#1}}{for {\bf \lastfunction}}% \itemzzz {#1}} \def\xitemzzz #1{\dosubind {kw}{\code{#1}}{for {\bf \xitemsubtopic}}% \itemzzz {#1}} \def\itemzzz #1{\begingroup % \advance\hsize by -\rightskip \advance\hsize by -\tableindent \setbox0=\hbox{\itemfont{#1}}% \itemindex{#1}% \nobreak % This prevents a break before @itemx. % % Be sure we are not still in the middle of a paragraph. %{\parskip = 0in %\par %}% % % If the item text does not fit in the space we have, put it on a line % by itself, and do not allow a page break either before or after that % line. We do not start a paragraph here because then if the next % command is, e.g., @kindex, the whatsit would get put into the % horizontal list on a line by itself, resulting in extra blank space. \ifdim \wd0>\itemmax % % Make this a paragraph so we get the \parskip glue and wrapping, % but leave it ragged-right. \begingroup \advance\leftskip by-\tableindent \advance\hsize by\tableindent \advance\rightskip by0pt plus1fil \leavevmode\unhbox0\par \endgroup % % We're going to be starting a paragraph, but we don't want the % \parskip glue -- logically it's part of the @item we just started. \nobreak \vskip-\parskip % % Stop a page break at the \parskip glue coming up. Unfortunately % we can't prevent a possible page break at the following % \baselineskip glue. \nobreak \endgroup \itemxneedsnegativevskipfalse \else % The item text fits into the space. Start a paragraph, so that the % following text (if any) will end up on the same line. Since that % text will be indented by \tableindent, we make the item text be in % a zero-width box. \noindent \rlap{\hskip -\tableindent\box0}\ignorespaces% \endgroup% \itemxneedsnegativevskiptrue% \fi } \def\item{\errmessage{@item while not in a table}} \def\itemx{\errmessage{@itemx while not in a table}} \def\kitem{\errmessage{@kitem while not in a table}} \def\kitemx{\errmessage{@kitemx while not in a table}} \def\xitem{\errmessage{@xitem while not in a table}} \def\xitemx{\errmessage{@xitemx while not in a table}} %% Contains a kludge to get @end[description] to work \def\description{\tablez{\dontindex}{1}{}{}{}{}} \def\table{\begingroup\inENV\obeylines\obeyspaces\tablex} {\obeylines\obeyspaces% \gdef\tablex #1^^M{% \tabley\dontindex#1 \endtabley}} \def\ftable{\begingroup\inENV\obeylines\obeyspaces\ftablex} {\obeylines\obeyspaces% \gdef\ftablex #1^^M{% \tabley\fnitemindex#1 \endtabley \def\Eftable{\endgraf\afterenvbreak\endgroup}% \let\Etable=\relax}} \def\vtable{\begingroup\inENV\obeylines\obeyspaces\vtablex} {\obeylines\obeyspaces% \gdef\vtablex #1^^M{% \tabley\vritemindex#1 \endtabley \def\Evtable{\endgraf\afterenvbreak\endgroup}% \let\Etable=\relax}} \def\dontindex #1{} \def\fnitemindex #1{\doind {fn}{\code{#1}}}% \def\vritemindex #1{\doind {vr}{\code{#1}}}% {\obeyspaces % \gdef\tabley#1#2 #3 #4 #5 #6 #7\endtabley{\endgroup% \tablez{#1}{#2}{#3}{#4}{#5}{#6}}} \def\tablez #1#2#3#4#5#6{% \aboveenvbreak % \begingroup % \def\Edescription{\Etable}% Neccessary kludge. \let\itemindex=#1% \ifnum 0#3>0 \advance \leftskip by #3\mil \fi % \ifnum 0#4>0 \tableindent=#4\mil \fi % \ifnum 0#5>0 \advance \rightskip by #5\mil \fi % \def\itemfont{#2}% \itemmax=\tableindent % \advance \itemmax by -\itemmargin % \advance \leftskip by \tableindent % \exdentamount=\tableindent \parindent = 0pt \parskip = \smallskipamount \ifdim \parskip=0pt \parskip=2pt \fi% \def\Etable{\endgraf\afterenvbreak\endgroup}% \let\item = \internalBitem % \let\itemx = \internalBitemx % \let\kitem = \internalBkitem % \let\kitemx = \internalBkitemx % \let\xitem = \internalBxitem % \let\xitemx = \internalBxitemx % } % This is the counter used by @enumerate, which is really @itemize \newcount \itemno \def\itemize{\parsearg\itemizezzz} \def\itemizezzz #1{% \begingroup % ended by the @end itemsize \itemizey {#1}{\Eitemize} } \def\itemizey #1#2{% \aboveenvbreak % \itemmax=\itemindent % \advance \itemmax by -\itemmargin % \advance \leftskip by \itemindent % \exdentamount=\itemindent \parindent = 0pt % \parskip = \smallskipamount % \ifdim \parskip=0pt \parskip=2pt \fi% \def#2{\endgraf\afterenvbreak\endgroup}% \def\itemcontents{#1}% \let\item=\itemizeitem} % Set sfcode to normal for the chars that usually have another value. % These are `.?!:;,' \def\frenchspacing{\sfcode46=1000 \sfcode63=1000 \sfcode33=1000 \sfcode58=1000 \sfcode59=1000 \sfcode44=1000 } % \splitoff TOKENS\endmark defines \first to be the first token in % TOKENS, and \rest to be the remainder. % \def\splitoff#1#2\endmark{\def\first{#1}\def\rest{#2}}% % Allow an optional argument of an uppercase letter, lowercase letter, % or number, to specify the first label in the enumerated list. No % argument is the same as `1'. % \def\enumerate{\parsearg\enumeratezzz} \def\enumeratezzz #1{\enumeratey #1 \endenumeratey} \def\enumeratey #1 #2\endenumeratey{% \begingroup % ended by the @end enumerate % % If we were given no argument, pretend we were given `1'. \def\thearg{#1}% \ifx\thearg\empty \def\thearg{1}\fi % % Detect if the argument is a single token. If so, it might be a % letter. Otherwise, the only valid thing it can be is a number. % (We will always have one token, because of the test we just made. % This is a good thing, since \splitoff doesn't work given nothing at % all -- the first parameter is undelimited.) \expandafter\splitoff\thearg\endmark \ifx\rest\empty % Only one token in the argument. It could still be anything. % A ``lowercase letter'' is one whose \lccode is nonzero. % An ``uppercase letter'' is one whose \lccode is both nonzero, and % not equal to itself. % Otherwise, we assume it's a number. % % We need the \relax at the end of the \ifnum lines to stop TeX from % continuing to look for a . % \ifnum\lccode\expandafter`\thearg=0\relax \numericenumerate % a number (we hope) \else % It's a letter. \ifnum\lccode\expandafter`\thearg=\expandafter`\thearg\relax \lowercaseenumerate % lowercase letter \else \uppercaseenumerate % uppercase letter \fi \fi \else % Multiple tokens in the argument. We hope it's a number. \numericenumerate \fi } % An @enumerate whose labels are integers. The starting integer is % given in \thearg. % \def\numericenumerate{% \itemno = \thearg \startenumeration{\the\itemno}% } % The starting (lowercase) letter is in \thearg. \def\lowercaseenumerate{% \itemno = \expandafter`\thearg \startenumeration{% % Be sure we're not beyond the end of the alphabet. \ifnum\itemno=0 \errmessage{No more lowercase letters in @enumerate; get a bigger alphabet}% \fi \char\lccode\itemno }% } % The starting (uppercase) letter is in \thearg. \def\uppercaseenumerate{% \itemno = \expandafter`\thearg \startenumeration{% % Be sure we're not beyond the end of the alphabet. \ifnum\itemno=0 \errmessage{No more uppercase letters in @enumerate; get a bigger alphabet} \fi \char\uccode\itemno }% } % Call itemizey, adding a period to the first argument and supplying the % common last two arguments. Also subtract one from the initial value in % \itemno, since @item increments \itemno. % \def\startenumeration#1{% \advance\itemno by -1 \itemizey{#1.}\Eenumerate\flushcr } % @alphaenumerate and @capsenumerate are abbreviations for giving an arg % to @enumerate. % \def\alphaenumerate{\enumerate{a}} \def\capsenumerate{\enumerate{A}} \def\Ealphaenumerate{\Eenumerate} \def\Ecapsenumerate{\Eenumerate} % Definition of @item while inside @itemize. \def\itemizeitem{% \advance\itemno by 1 {\let\par=\endgraf \smallbreak}% \ifhmode \errmessage{\in hmode at itemizeitem}\fi {\parskip=0in \hskip 0pt \hbox to 0pt{\hss \itemcontents\hskip \itemmargin}% \vadjust{\penalty 1200}}% \flushcr} % @multitable macros % Amy Hendrickson, 8/18/94 % % @multitable ... @endmultitable will make as many columns as desired. % Contents of each column will wrap at width given in preamble. Width % can be specified either with sample text given in a template line, % or in percent of \hsize, the current width of text on page. % Table can continue over pages but will only break between lines. % To make preamble: % % Either define widths of columns in terms of percent of \hsize: % @multitable @percentofhsize .2 .3 .5 % @item ... % % Numbers following @percentofhsize are the percent of the total % current hsize to be used for each column. You may use as many % columns as desired. % Or use a template: % @multitable {Column 1 template} {Column 2 template} {Column 3 template} % @item ... % using the widest term desired in each column. % Each new table line starts with @item, each subsequent new column % starts with @tab. Empty columns may be produced by supplying @tab's % with nothing between them for as many times as empty columns are needed, % ie, @tab@tab@tab will produce two empty columns. % @item, @tab, @multicolumn or @endmulticolumn do not need to be on their % own lines, but it will not hurt if they are. % Sample multitable: % @multitable {Column 1 template} {Column 2 template} {Column 3 template} % @item first col stuff @tab second col stuff @tab third col % @item % first col stuff % @tab % second col stuff % @tab % third col % @item first col stuff @tab second col stuff % @tab Many paragraphs of text may be used in any column. % % They will wrap at the width determined by the template. % @item@tab@tab This will be in third column. % @endmultitable % Default dimensions may be reset by user. % @intableparskip will set vertical space between paragraphs in table. % @intableparindent will set paragraph indent in table. % @spacebetweencols will set horizontal space to be left between columns. % @spacebetweenlines will set vertical space to be left between lines. %%%% % Dimensions \newdimen\intableparskip \newdimen\intableparindent \newdimen\spacebetweencols \newdimen\spacebetweenlines \intableparskip=0pt \intableparindent=6pt \spacebetweencols=12pt \spacebetweenlines=12pt %%%% % Macros used to set up halign preamble: \let\endsetuptable\relax \def\xendsetuptable{\endsetuptable} \let\percentofhsize\relax \def\xpercentofhsize{\percentofhsize} \newif\ifsetpercent \newcount\colcount \def\setuptable#1{\def\firstarg{#1}% \ifx\firstarg\xendsetuptable\let\go\relax% \else \ifx\firstarg\xpercentofhsize\global\setpercenttrue% \else \ifsetpercent \if#1.\else% \global\advance\colcount by1 % \expandafter\xdef\csname col\the\colcount\endcsname{.#1\hsize}% \fi \else \global\advance\colcount by1 \setbox0=\hbox{#1}% \expandafter\xdef\csname col\the\colcount\endcsname{\the\wd0}% \fi% \fi% \let\go\setuptable% \fi\go} %%%% % multitable syntax \def\tab{&} %%%% % @multitable ... @endmultitable definitions: \def\multitable#1\item{\bgroup \let\item\cr \tolerance=9500 \hbadness=9500 \parskip=\intableparskip \parindent=\intableparindent \overfullrule=0pt \global\colcount=0\relax% \def\Emultitable{\global\setpercentfalse\global\everycr{}\cr\egroup\egroup}% % To parse everything between @multitable and @item : \def\one{#1}\expandafter\setuptable\one\endsetuptable % Need to reset this to 0 after \setuptable. \global\colcount=0\relax% % % This preamble sets up a generic column definition, which will % be used as many times as user calls for columns. % \vtop will set a single line and will also let text wrap and % continue for many paragraphs if desired. \halign\bgroup&\global\advance\colcount by 1\relax% \vtop{\hsize=\expandafter\csname col\the\colcount\endcsname % In order to keep entries from bumping into each other % we will add a \leftskip of \spacebetweencols to all columns after % the first one. % If a template has been used, we will add \spacebetweencols % to the width of each template entry. % If user has set preamble in terms of percent of \hsize % we will use that dimension as the width of the column, and % the \leftskip will keep entries from bumping into each other. % Table will start at left margin and final column will justify at % right margin. \ifnum\colcount=1 \else \ifsetpercent \else % If user has set preamble in terms of percent of \hsize % we will advance \hsize by \spacebetweencols \advance\hsize by \spacebetweencols \fi % In either case we will make \leftskip=\spacebetweencols: \leftskip=\spacebetweencols \fi \noindent##}\cr% % \everycr will reset column counter, \colcount, at the end of % each line. Every column entry will cause \colcount to advance by one. % The table preamble % looks at the current \colcount to find the correct column width. \global\everycr{\noalign{\nointerlineskip\vskip\spacebetweenlines \filbreak%% keeps underfull box messages off when table breaks over pages. \global\colcount=0\relax}}} \message{indexing,} % Index generation facilities % Define \newwrite to be identical to plain tex's \newwrite % except not \outer, so it can be used within \newindex. {\catcode`\@=11 \gdef\newwrite{\alloc@7\write\chardef\sixt@@n}} % \newindex {foo} defines an index named foo. % It automatically defines \fooindex such that % \fooindex ...rest of line... puts an entry in the index foo. % It also defines \fooindfile to be the number of the output channel for % the file that accumulates this index. The file's extension is foo. % The name of an index should be no more than 2 characters long % for the sake of vms. \def\newindex #1{ \expandafter\newwrite \csname#1indfile\endcsname% Define number for output file \openout \csname#1indfile\endcsname \jobname.#1 % Open the file \expandafter\xdef\csname#1index\endcsname{% % Define \xxxindex \noexpand\doindex {#1}} } % @defindex foo == \newindex{foo} \def\defindex{\parsearg\newindex} % Define @defcodeindex, like @defindex except put all entries in @code. \def\newcodeindex #1{ \expandafter\newwrite \csname#1indfile\endcsname% Define number for output file \openout \csname#1indfile\endcsname \jobname.#1 % Open the file \expandafter\xdef\csname#1index\endcsname{% % Define \xxxindex \noexpand\docodeindex {#1}} } \def\defcodeindex{\parsearg\newcodeindex} % @synindex foo bar makes index foo feed into index bar. % Do this instead of @defindex foo if you don't want it as a separate index. \def\synindex #1 #2 {% \expandafter\let\expandafter\synindexfoo\expandafter=\csname#2indfile\endcsname \expandafter\let\csname#1indfile\endcsname=\synindexfoo \expandafter\xdef\csname#1index\endcsname{% % Define \xxxindex \noexpand\doindex {#2}}% } % @syncodeindex foo bar similar, but put all entries made for index foo % inside @code. \def\syncodeindex #1 #2 {% \expandafter\let\expandafter\synindexfoo\expandafter=\csname#2indfile\endcsname \expandafter\let\csname#1indfile\endcsname=\synindexfoo \expandafter\xdef\csname#1index\endcsname{% % Define \xxxindex \noexpand\docodeindex {#2}}% } % Define \doindex, the driver for all \fooindex macros. % Argument #1 is generated by the calling \fooindex macro, % and it is "foo", the name of the index. % \doindex just uses \parsearg; it calls \doind for the actual work. % This is because \doind is more useful to call from other macros. % There is also \dosubind {index}{topic}{subtopic} % which makes an entry in a two-level index such as the operation index. \def\doindex#1{\edef\indexname{#1}\parsearg\singleindexer} \def\singleindexer #1{\doind{\indexname}{#1}} % like the previous two, but they put @code around the argument. \def\docodeindex#1{\edef\indexname{#1}\parsearg\singlecodeindexer} \def\singlecodeindexer #1{\doind{\indexname}{\code{#1}}} \def\indexdummies{% % Take care of the plain tex accent commands. \def\"{\realbackslash "}% \def\`{\realbackslash `}% \def\'{\realbackslash '}% \def\^{\realbackslash ^}% \def\~{\realbackslash ~}% \def\={\realbackslash =}% \def\b{\realbackslash b}% \def\c{\realbackslash c}% \def\d{\realbackslash d}% \def\u{\realbackslash u}% \def\v{\realbackslash v}% \def\H{\realbackslash H}% % Take care of the plain tex special European modified letters. \def\oe{\realbackslash oe}% \def\ae{\realbackslash ae}% \def\aa{\realbackslash aa}% \def\OE{\realbackslash OE}% \def\AE{\realbackslash AE}% \def\AA{\realbackslash AA}% \def\o{\realbackslash o}% \def\O{\realbackslash O}% \def\l{\realbackslash l}% \def\L{\realbackslash L}% \def\ss{\realbackslash ss}% % Take care of texinfo commands likely to appear in an index entry. \def\_{{\realbackslash _}}% \def\w{\realbackslash w }% \def\bf{\realbackslash bf }% \def\rm{\realbackslash rm }% \def\sl{\realbackslash sl }% \def\sf{\realbackslash sf}% \def\tt{\realbackslash tt}% \def\gtr{\realbackslash gtr}% \def\less{\realbackslash less}% \def\hat{\realbackslash hat}% \def\char{\realbackslash char}% \def\TeX{\realbackslash TeX}% \def\dots{\realbackslash dots }% \def\copyright{\realbackslash copyright }% \def\tclose##1{\realbackslash tclose {##1}}% \def\code##1{\realbackslash code {##1}}% \def\samp##1{\realbackslash samp {##1}}% \def\t##1{\realbackslash r {##1}}% \def\r##1{\realbackslash r {##1}}% \def\i##1{\realbackslash i {##1}}% \def\b##1{\realbackslash b {##1}}% \def\cite##1{\realbackslash cite {##1}}% \def\key##1{\realbackslash key {##1}}% \def\file##1{\realbackslash file {##1}}% \def\var##1{\realbackslash var {##1}}% \def\kbd##1{\realbackslash kbd {##1}}% \def\dfn##1{\realbackslash dfn {##1}}% \def\emph##1{\realbackslash emph {##1}}% } % \indexnofonts no-ops all font-change commands. % This is used when outputting the strings to sort the index by. \def\indexdummyfont#1{#1} \def\indexdummytex{TeX} \def\indexdummydots{...} \def\indexnofonts{% % Just ignore accents. \let\"=\indexdummyfont \let\`=\indexdummyfont \let\'=\indexdummyfont \let\^=\indexdummyfont \let\~=\indexdummyfont \let\==\indexdummyfont \let\b=\indexdummyfont \let\c=\indexdummyfont \let\d=\indexdummyfont \let\u=\indexdummyfont \let\v=\indexdummyfont \let\H=\indexdummyfont % Take care of the plain tex special European modified letters. \def\oe{oe}% \def\ae{ae}% \def\aa{aa}% \def\OE{OE}% \def\AE{AE}% \def\AA{AA}% \def\o{o}% \def\O{O}% \def\l{l}% \def\L{L}% \def\ss{ss}% \let\w=\indexdummyfont \let\t=\indexdummyfont \let\r=\indexdummyfont \let\i=\indexdummyfont \let\b=\indexdummyfont \let\emph=\indexdummyfont \let\strong=\indexdummyfont \let\cite=\indexdummyfont \let\sc=\indexdummyfont %Don't no-op \tt, since it isn't a user-level command % and is used in the definitions of the active chars like <, >, |... %\let\tt=\indexdummyfont \let\tclose=\indexdummyfont \let\code=\indexdummyfont \let\file=\indexdummyfont \let\samp=\indexdummyfont \let\kbd=\indexdummyfont \let\key=\indexdummyfont \let\var=\indexdummyfont \let\TeX=\indexdummytex \let\dots=\indexdummydots } % To define \realbackslash, we must make \ not be an escape. % We must first make another character (@) an escape % so we do not become unable to do a definition. {\catcode`\@=0 \catcode`\\=\other @gdef@realbackslash{\}} \let\indexbackslash=0 %overridden during \printindex. \let\SETmarginindex=\relax %initialize! % workhorse for all \fooindexes % #1 is name of index, #2 is stuff to put there \def\doind #1#2{% % Put the index entry in the margin if desired. \ifx\SETmarginindex\relax\else% \insert\margin{\hbox{\vrule height8pt depth3pt width0pt #2}}% \fi% {\count10=\lastpenalty % {\indexdummies % Must do this here, since \bf, etc expand at this stage \escapechar=`\\% {\let\folio=0% Expand all macros now EXCEPT \folio \def\rawbackslashxx{\indexbackslash}% \indexbackslash isn't defined now % so it will be output as is; and it will print as backslash in the indx. % % Now process the index-string once, with all font commands turned off, % to get the string to sort the index by. {\indexnofonts \xdef\temp1{#2}% }% % Now produce the complete index entry. We process the index-string again, % this time with font commands expanded, to get what to print in the index. \edef\temp{% \write \csname#1indfile\endcsname{% \realbackslash entry {\temp1}{\folio}{#2}}}% \temp }% }\penalty\count10}} \def\dosubind #1#2#3{% {\count10=\lastpenalty % {\indexdummies % Must do this here, since \bf, etc expand at this stage \escapechar=`\\% {\let\folio=0% \def\rawbackslashxx{\indexbackslash}% % % Now process the index-string once, with all font commands turned off, % to get the string to sort the index by. {\indexnofonts \xdef\temp1{#2 #3}% }% % Now produce the complete index entry. We process the index-string again, % this time with font commands expanded, to get what to print in the index. \edef\temp{% \write \csname#1indfile\endcsname{% \realbackslash entry {\temp1}{\folio}{#2}{#3}}}% \temp }% }\penalty\count10}} % The index entry written in the file actually looks like % \entry {sortstring}{page}{topic} % or % \entry {sortstring}{page}{topic}{subtopic} % The texindex program reads in these files and writes files % containing these kinds of lines: % \initial {c} % before the first topic whose initial is c % \entry {topic}{pagelist} % for a topic that is used without subtopics % \primary {topic} % for the beginning of a topic that is used with subtopics % \secondary {subtopic}{pagelist} % for each subtopic. % Define the user-accessible indexing commands % @findex, @vindex, @kindex, @cindex. \def\findex {\fnindex} \def\kindex {\kyindex} \def\cindex {\cpindex} \def\vindex {\vrindex} \def\tindex {\tpindex} \def\pindex {\pgindex} \def\cindexsub {\begingroup\obeylines\cindexsub} {\obeylines % \gdef\cindexsub "#1" #2^^M{\endgroup % \dosubind{cp}{#2}{#1}}} % Define the macros used in formatting output of the sorted index material. % This is what you call to cause a particular index to get printed. % Write % @unnumbered Function Index % @printindex fn \def\printindex{\parsearg\doprintindex} \def\doprintindex#1{% \tex \dobreak \chapheadingskip {10000} \catcode`\%=\other\catcode`\&=\other\catcode`\#=\other \catcode`\$=\other \catcode`\~=\other \indexbreaks % % The following don't help, since the chars were translated % when the raw index was written, and their fonts were discarded % due to \indexnofonts. %\catcode`\"=\active %\catcode`\^=\active %\catcode`\_=\active %\catcode`\|=\active %\catcode`\<=\active %\catcode`\>=\active % % \def\indexbackslash{\rawbackslashxx} \indexfonts\rm \tolerance=9500 \advance\baselineskip -1pt \begindoublecolumns % % See if the index file exists and is nonempty. \openin 1 \jobname.#1s \ifeof 1 % \enddoublecolumns gets confused if there is no text in the index, % and it loses the chapter title and the aux file entries for the % index. The easiest way to prevent this problem is to make sure % there is some text. (Index is nonexistent) \else % % If the index file exists but is empty, then \openin leaves \ifeof % false. We have to make TeX try to read something from the file, so % it can discover if there is anything in it. \read 1 to \temp \ifeof 1 (Index is empty) \else \input \jobname.#1s \fi \fi \closein 1 \enddoublecolumns \Etex } % These macros are used by the sorted index file itself. % Change them to control the appearance of the index. % Same as \bigskipamount except no shrink. % \balancecolumns gets confused if there is any shrink. \newskip\initialskipamount \initialskipamount 12pt plus4pt \def\initial #1{% {\let\tentt=\sectt \let\tt=\sectt \let\sf=\sectt \ifdim\lastskip<\initialskipamount \removelastskip \penalty-200 \vskip \initialskipamount\fi \line{\secbf#1\hfill}\kern 2pt\penalty10000}} % This typesets a paragraph consisting of #1, dot leaders, and then #2 % flush to the right margin. It is used for index and table of contents % entries. The paragraph is indented by \leftskip. % \def\entry #1#2{\begingroup % % Start a new paragraph if necessary, so our assignments below can't % affect previous text. \par % % Do not fill out the last line with white space. \parfillskip = 0in % % No extra space above this paragraph. \parskip = 0in % % Do not prefer a separate line ending with a hyphen to fewer lines. \finalhyphendemerits = 0 % % \hangindent is only relevant when the entry text and page number % don't both fit on one line. In that case, bob suggests starting the % dots pretty far over on the line. Unfortunately, a large % indentation looks wrong when the entry text itself is broken across % lines. So we use a small indentation and put up with long leaders. % % \hangafter is reset to 1 (which is the value we want) at the start % of each paragraph, so we need not do anything with that. \hangindent=2em % % When the entry text needs to be broken, just fill out the first line % with blank space. \rightskip = 0pt plus1fil % % Start a ``paragraph'' for the index entry so the line breaking % parameters we've set above will have an effect. \noindent % % Insert the text of the index entry. TeX will do line-breaking on it. #1% % The following is kluged to not output a line of dots in the index if % there are no page numbers. The next person who breaks this will be % cursed by a Unix daemon. \def\tempa{{\rm }}% \def\tempb{#2}% \edef\tempc{\tempa}% \edef\tempd{\tempb}% \ifx\tempc\tempd\ \else% % % If we must, put the page number on a line of its own, and fill out % this line with blank space. (The \hfil is overwhelmed with the % fill leaders glue in \indexdotfill if the page number does fit.) \hfil\penalty50 \null\nobreak\indexdotfill % Have leaders before the page number. % % The `\ ' here is removed by the implicit \unskip that TeX does as % part of (the primitive) \par. Without it, a spurious underfull % \hbox ensues. \ #2% The page number ends the paragraph. \fi% \par \endgroup} % Like \dotfill except takes at least 1 em. \def\indexdotfill{\cleaders \hbox{$\mathsurround=0pt \mkern1.5mu ${\it .}$ \mkern1.5mu$}\hskip 1em plus 1fill} \def\primary #1{\line{#1\hfil}} \newskip\secondaryindent \secondaryindent=0.5cm \def\secondary #1#2{ {\parfillskip=0in \parskip=0in \hangindent =1in \hangafter=1 \noindent\hskip\secondaryindent\hbox{#1}\indexdotfill #2\par }} %% Define two-column mode, which is used in indexes. %% Adapted from the TeXbook, page 416. \catcode `\@=11 \newbox\partialpage \newdimen\doublecolumnhsize \def\begindoublecolumns{\begingroup % Grab any single-column material above us. \output = {\global\setbox\partialpage =\vbox{\unvbox255\kern -\topskip \kern \baselineskip}}% \eject % % Now switch to the double-column output routine. \output={\doublecolumnout}% % % Change the page size parameters. We could do this once outside this % routine, in each of @smallbook, @afourpaper, and the default 8.5x11 % format, but then we repeat the same computation. Repeating a couple % of assignments once per index is clearly meaningless for the % execution time, so we may as well do it once. % % First we halve the line length, less a little for the gutter between % the columns. We compute the gutter based on the line length, so it % changes automatically with the paper format. The magic constant % below is chosen so that the gutter has the same value (well, +- < % 1pt) as it did when we hard-coded it. % % We put the result in a separate register, \doublecolumhsize, so we % can restore it in \pagesofar, after \hsize itself has (potentially) % been clobbered. % \doublecolumnhsize = \hsize \advance\doublecolumnhsize by -.04154\hsize \divide\doublecolumnhsize by 2 \hsize = \doublecolumnhsize % % Double the \vsize as well. (We don't need a separate register here, % since nobody clobbers \vsize.) \vsize = 2\vsize \doublecolumnpagegoal } \def\enddoublecolumns{\eject \endgroup \pagegoal=\vsize \unvbox\partialpage} \def\doublecolumnsplit{\splittopskip=\topskip \splitmaxdepth=\maxdepth \global\dimen@=\pageheight \global\advance\dimen@ by-\ht\partialpage \global\setbox1=\vsplit255 to\dimen@ \global\setbox0=\vbox{\unvbox1} \global\setbox3=\vsplit255 to\dimen@ \global\setbox2=\vbox{\unvbox3} \ifdim\ht0>\dimen@ \setbox255=\vbox{\unvbox0\unvbox2} \global\setbox255=\copy5 \fi \ifdim\ht2>\dimen@ \setbox255=\vbox{\unvbox0\unvbox2} \global\setbox255=\copy5 \fi } \def\doublecolumnpagegoal{% \dimen@=\vsize \advance\dimen@ by-2\ht\partialpage \global\pagegoal=\dimen@ } \def\pagesofar{\unvbox\partialpage % \hsize=\doublecolumnhsize % have to restore this since output routine \wd0=\hsize \wd2=\hsize \hbox to\pagewidth{\box0\hfil\box2}} \def\doublecolumnout{% \setbox5=\copy255 {\vbadness=10000 \doublecolumnsplit} \ifvbox255 \setbox0=\vtop to\dimen@{\unvbox0} \setbox2=\vtop to\dimen@{\unvbox2} \onepageout\pagesofar \unvbox255 \penalty\outputpenalty \else \setbox0=\vbox{\unvbox5} \ifvbox0 \dimen@=\ht0 \advance\dimen@ by\topskip \advance\dimen@ by-\baselineskip \divide\dimen@ by2 \splittopskip=\topskip \splitmaxdepth=\maxdepth {\vbadness=10000 \loop \global\setbox5=\copy0 \setbox1=\vsplit5 to\dimen@ \setbox3=\vsplit5 to\dimen@ \ifvbox5 \global\advance\dimen@ by1pt \repeat \setbox0=\vbox to\dimen@{\unvbox1} \setbox2=\vbox to\dimen@{\unvbox3} \global\setbox\partialpage=\vbox{\pagesofar} \doublecolumnpagegoal } \fi \fi } \catcode `\@=\other \message{sectioning,} % Define chapters, sections, etc. \newcount \chapno \newcount \secno \secno=0 \newcount \subsecno \subsecno=0 \newcount \subsubsecno \subsubsecno=0 % This counter is funny since it counts through charcodes of letters A, B, ... \newcount \appendixno \appendixno = `\@ \def\appendixletter{\char\the\appendixno} \newwrite \contentsfile % This is called from \setfilename. \def\opencontents{\openout \contentsfile = \jobname.toc} % Each @chapter defines this as the name of the chapter. % page headings and footings can use it. @section does likewise \def\thischapter{} \def\thissection{} \def\seccheck#1{\if \pageno<0 % \errmessage{@#1 not allowed after generating table of contents}\fi % } \def\chapternofonts{% \let\rawbackslash=\relax% \let\frenchspacing=\relax% \def\result{\realbackslash result} \def\equiv{\realbackslash equiv} \def\expansion{\realbackslash expansion} \def\print{\realbackslash print} \def\TeX{\realbackslash TeX} \def\dots{\realbackslash dots} \def\copyright{\realbackslash copyright} \def\tt{\realbackslash tt} \def\bf{\realbackslash bf } \def\w{\realbackslash w} \def\less{\realbackslash less} \def\gtr{\realbackslash gtr} \def\hat{\realbackslash hat} \def\char{\realbackslash char} \def\tclose##1{\realbackslash tclose {##1}} \def\code##1{\realbackslash code {##1}} \def\samp##1{\realbackslash samp {##1}} \def\r##1{\realbackslash r {##1}} \def\b##1{\realbackslash b {##1}} \def\key##1{\realbackslash key {##1}} \def\file##1{\realbackslash file {##1}} \def\kbd##1{\realbackslash kbd {##1}} % These are redefined because @smartitalic wouldn't work inside xdef. \def\i##1{\realbackslash i {##1}} \def\cite##1{\realbackslash cite {##1}} \def\var##1{\realbackslash var {##1}} \def\emph##1{\realbackslash emph {##1}} \def\dfn##1{\realbackslash dfn {##1}} } \newcount\absseclevel % used to calculate proper heading level \newcount\secbase\secbase=0 % @raise/lowersections modify this count % @raisesections: treat @section as chapter, @subsection as section, etc. \def\raisesections{\global\advance\secbase by -1} \let\up=\raisesections % original BFox name % @lowersections: treat @chapter as section, @section as subsection, etc. \def\lowersections{\global\advance\secbase by 1} \let\down=\lowersections % original BFox name % Choose a numbered-heading macro % #1 is heading level if unmodified by @raisesections or @lowersections % #2 is text for heading \def\numhead#1#2{\absseclevel=\secbase\advance\absseclevel by #1 \ifcase\absseclevel \chapterzzz{#2} \or \seczzz{#2} \or \numberedsubseczzz{#2} \or \numberedsubsubseczzz{#2} \else \ifnum \absseclevel<0 \chapterzzz{#2} \else \numberedsubsubseczzz{#2} \fi \fi } % like \numhead, but chooses appendix heading levels \def\apphead#1#2{\absseclevel=\secbase\advance\absseclevel by #1 \ifcase\absseclevel \appendixzzz{#2} \or \appendixsectionzzz{#2} \or \appendixsubseczzz{#2} \or \appendixsubsubseczzz{#2} \else \ifnum \absseclevel<0 \appendixzzz{#2} \else \appendixsubsubseczzz{#2} \fi \fi } % like \numhead, but chooses numberless heading levels \def\unnmhead#1#2{\absseclevel=\secbase\advance\absseclevel by #1 \ifcase\absseclevel \unnumberedzzz{#2} \or \unnumberedseczzz{#2} \or \unnumberedsubseczzz{#2} \or \unnumberedsubsubseczzz{#2} \else \ifnum \absseclevel<0 \unnumberedzzz{#2} \else \unnumberedsubsubseczzz{#2} \fi \fi } \def\thischaptername{No Chapter Title} \outer\def\chapter{\parsearg\chapteryyy} \def\chapteryyy #1{\numhead0{#1}} % normally numhead0 calls chapterzzz \def\chapterzzz #1{\seccheck{chapter}% \secno=0 \subsecno=0 \subsubsecno=0 \global\advance \chapno by 1 \message{\putwordChapter \the\chapno}% \chapmacro {#1}{\the\chapno}% \gdef\thissection{#1}% \gdef\thischaptername{#1}% % We don't substitute the actual chapter name into \thischapter % because we don't want its macros evaluated now. \xdef\thischapter{\putwordChapter{} \the\chapno: \noexpand\thischaptername}% {\chapternofonts% \edef\temp{{\realbackslash chapentry {#1}{\the\chapno}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \donoderef % \global\let\section = \numberedsec \global\let\subsection = \numberedsubsec \global\let\subsubsection = \numberedsubsubsec }} \outer\def\appendix{\parsearg\appendixyyy} \def\appendixyyy #1{\apphead0{#1}} % normally apphead0 calls appendixzzz \def\appendixzzz #1{\seccheck{appendix}% \secno=0 \subsecno=0 \subsubsecno=0 \global\advance \appendixno by 1 \message{Appendix \appendixletter}% \chapmacro {#1}{\putwordAppendix{} \appendixletter}% \gdef\thissection{#1}% \gdef\thischaptername{#1}% \xdef\thischapter{\putwordAppendix{} \appendixletter: \noexpand\thischaptername}% {\chapternofonts% \edef\temp{{\realbackslash chapentry {#1}{\putwordAppendix{} \appendixletter}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \appendixnoderef % \global\let\section = \appendixsec \global\let\subsection = \appendixsubsec \global\let\subsubsection = \appendixsubsubsec }} \outer\def\top{\parsearg\unnumberedyyy} \outer\def\unnumbered{\parsearg\unnumberedyyy} \def\unnumberedyyy #1{\unnmhead0{#1}} % normally unnmhead0 calls unnumberedzzz \def\unnumberedzzz #1{\seccheck{unnumbered}% \secno=0 \subsecno=0 \subsubsecno=0 % % This used to be simply \message{#1}, but TeX fully expands the % argument to \message. Therefore, if #1 contained @-commands, TeX % expanded them. For example, in `@unnumbered The @cite{Book}', TeX % expanded @cite (which turns out to cause errors because \cite is meant % to be executed, not expanded). % % Anyway, we don't want the fully-expanded definition of @cite to appear % as a result of the \message, we just want `@cite' itself. We use % \the to achieve this: TeX expands \the only once, % simply yielding the contents of the . \toks0 = {#1}\message{(\the\toks0)}% % \unnumbchapmacro {#1}% \gdef\thischapter{#1}\gdef\thissection{#1}% {\chapternofonts% \edef\temp{{\realbackslash unnumbchapentry {#1}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \unnumbnoderef % \global\let\section = \unnumberedsec \global\let\subsection = \unnumberedsubsec \global\let\subsubsection = \unnumberedsubsubsec }} \outer\def\numberedsec{\parsearg\secyyy} \def\secyyy #1{\numhead1{#1}} % normally calls seczzz \def\seczzz #1{\seccheck{section}% \subsecno=0 \subsubsecno=0 \global\advance \secno by 1 % \gdef\thissection{#1}\secheading {#1}{\the\chapno}{\the\secno}% {\chapternofonts% \edef\temp{{\realbackslash secentry % {#1}{\the\chapno}{\the\secno}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \donoderef % \penalty 10000 % }} \outer\def\appenixsection{\parsearg\appendixsecyyy} \outer\def\appendixsec{\parsearg\appendixsecyyy} \def\appendixsecyyy #1{\apphead1{#1}} % normally calls appendixsectionzzz \def\appendixsectionzzz #1{\seccheck{appendixsection}% \subsecno=0 \subsubsecno=0 \global\advance \secno by 1 % \gdef\thissection{#1}\secheading {#1}{\appendixletter}{\the\secno}% {\chapternofonts% \edef\temp{{\realbackslash secentry % {#1}{\appendixletter}{\the\secno}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \appendixnoderef % \penalty 10000 % }} \outer\def\unnumberedsec{\parsearg\unnumberedsecyyy} \def\unnumberedsecyyy #1{\unnmhead1{#1}} % normally calls unnumberedseczzz \def\unnumberedseczzz #1{\seccheck{unnumberedsec}% \plainsecheading {#1}\gdef\thissection{#1}% {\chapternofonts% \edef\temp{{\realbackslash unnumbsecentry{#1}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \unnumbnoderef % \penalty 10000 % }} \outer\def\numberedsubsec{\parsearg\numberedsubsecyyy} \def\numberedsubsecyyy #1{\numhead2{#1}} % normally calls numberedsubseczzz \def\numberedsubseczzz #1{\seccheck{subsection}% \gdef\thissection{#1}\subsubsecno=0 \global\advance \subsecno by 1 % \subsecheading {#1}{\the\chapno}{\the\secno}{\the\subsecno}% {\chapternofonts% \edef\temp{{\realbackslash subsecentry % {#1}{\the\chapno}{\the\secno}{\the\subsecno}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \donoderef % \penalty 10000 % }} \outer\def\appendixsubsec{\parsearg\appendixsubsecyyy} \def\appendixsubsecyyy #1{\apphead2{#1}} % normally calls appendixsubseczzz \def\appendixsubseczzz #1{\seccheck{appendixsubsec}% \gdef\thissection{#1}\subsubsecno=0 \global\advance \subsecno by 1 % \subsecheading {#1}{\appendixletter}{\the\secno}{\the\subsecno}% {\chapternofonts% \edef\temp{{\realbackslash subsecentry % {#1}{\appendixletter}{\the\secno}{\the\subsecno}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \appendixnoderef % \penalty 10000 % }} \outer\def\unnumberedsubsec{\parsearg\unnumberedsubsecyyy} \def\unnumberedsubsecyyy #1{\unnmhead2{#1}} %normally calls unnumberedsubseczzz \def\unnumberedsubseczzz #1{\seccheck{unnumberedsubsec}% \plainsecheading {#1}\gdef\thissection{#1}% {\chapternofonts% \edef\temp{{\realbackslash unnumbsubsecentry{#1}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \unnumbnoderef % \penalty 10000 % }} \outer\def\numberedsubsubsec{\parsearg\numberedsubsubsecyyy} \def\numberedsubsubsecyyy #1{\numhead3{#1}} % normally numberedsubsubseczzz \def\numberedsubsubseczzz #1{\seccheck{subsubsection}% \gdef\thissection{#1}\global\advance \subsubsecno by 1 % \subsubsecheading {#1} {\the\chapno}{\the\secno}{\the\subsecno}{\the\subsubsecno}% {\chapternofonts% \edef\temp{{\realbackslash subsubsecentry % {#1} {\the\chapno}{\the\secno}{\the\subsecno}{\the\subsubsecno} {\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \donoderef % \penalty 10000 % }} \outer\def\appendixsubsubsec{\parsearg\appendixsubsubsecyyy} \def\appendixsubsubsecyyy #1{\apphead3{#1}} % normally appendixsubsubseczzz \def\appendixsubsubseczzz #1{\seccheck{appendixsubsubsec}% \gdef\thissection{#1}\global\advance \subsubsecno by 1 % \subsubsecheading {#1} {\appendixletter}{\the\secno}{\the\subsecno}{\the\subsubsecno}% {\chapternofonts% \edef\temp{{\realbackslash subsubsecentry{#1}% {\appendixletter} {\the\secno}{\the\subsecno}{\the\subsubsecno}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \appendixnoderef % \penalty 10000 % }} \outer\def\unnumberedsubsubsec{\parsearg\unnumberedsubsubsecyyy} \def\unnumberedsubsubsecyyy #1{\unnmhead3{#1}} %normally unnumberedsubsubseczzz \def\unnumberedsubsubseczzz #1{\seccheck{unnumberedsubsubsec}% \plainsecheading {#1}\gdef\thissection{#1}% {\chapternofonts% \edef\temp{{\realbackslash unnumbsubsubsecentry{#1}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \unnumbnoderef % \penalty 10000 % }} % These are variants which are not "outer", so they can appear in @ifinfo. % Actually, they should now be obsolete; ordinary section commands should work. \def\infotop{\parsearg\unnumberedzzz} \def\infounnumbered{\parsearg\unnumberedzzz} \def\infounnumberedsec{\parsearg\unnumberedseczzz} \def\infounnumberedsubsec{\parsearg\unnumberedsubseczzz} \def\infounnumberedsubsubsec{\parsearg\unnumberedsubsubseczzz} \def\infoappendix{\parsearg\appendixzzz} \def\infoappendixsec{\parsearg\appendixseczzz} \def\infoappendixsubsec{\parsearg\appendixsubseczzz} \def\infoappendixsubsubsec{\parsearg\appendixsubsubseczzz} \def\infochapter{\parsearg\chapterzzz} \def\infosection{\parsearg\sectionzzz} \def\infosubsection{\parsearg\subsectionzzz} \def\infosubsubsection{\parsearg\subsubsectionzzz} % These macros control what the section commands do, according % to what kind of chapter we are in (ordinary, appendix, or unnumbered). % Define them by default for a numbered chapter. \global\let\section = \numberedsec \global\let\subsection = \numberedsubsec \global\let\subsubsection = \numberedsubsubsec % Define @majorheading, @heading and @subheading % NOTE on use of \vbox for chapter headings, section headings, and % such: % 1) We use \vbox rather than the earlier \line to permit % overlong headings to fold. % 2) \hyphenpenalty is set to 10000 because hyphenation in a % heading is obnoxious; this forbids it. % 3) Likewise, headings look best if no \parindent is used, and % if justification is not attempted. Hence \raggedright. \def\majorheading{\parsearg\majorheadingzzz} \def\majorheadingzzz #1{% {\advance\chapheadingskip by 10pt \chapbreak }% {\chapfonts \vbox{\hyphenpenalty=10000\tolerance=5000 \parindent=0pt\raggedright \rm #1\hfill}}\bigskip \par\penalty 200} \def\chapheading{\parsearg\chapheadingzzz} \def\chapheadingzzz #1{\chapbreak % {\chapfonts \vbox{\hyphenpenalty=10000\tolerance=5000 \parindent=0pt\raggedright \rm #1\hfill}}\bigskip \par\penalty 200} \def\heading{\parsearg\secheadingi} \def\subheading{\parsearg\subsecheadingi} \def\subsubheading{\parsearg\subsubsecheadingi} % These macros generate a chapter, section, etc. heading only % (including whitespace, linebreaking, etc. around it), % given all the information in convenient, parsed form. %%% Args are the skip and penalty (usually negative) \def\dobreak#1#2{\par\ifdim\lastskip<#1\removelastskip\penalty#2\vskip#1\fi} \def\setchapterstyle #1 {\csname CHAPF#1\endcsname} %%% Define plain chapter starts, and page on/off switching for it % Parameter controlling skip before chapter headings (if needed) \newskip \chapheadingskip \chapheadingskip = 30pt plus 8pt minus 4pt \def\chapbreak{\dobreak \chapheadingskip {-4000}} \def\chappager{\par\vfill\supereject} \def\chapoddpage{\chappager \ifodd\pageno \else \hbox to 0pt{} \chappager\fi} \def\setchapternewpage #1 {\csname CHAPPAG#1\endcsname} \def\CHAPPAGoff{ \global\let\pchapsepmacro=\chapbreak \global\let\pagealignmacro=\chappager} \def\CHAPPAGon{ \global\let\pchapsepmacro=\chappager \global\let\pagealignmacro=\chappager \global\def\HEADINGSon{\HEADINGSsingle}} \def\CHAPPAGodd{ \global\let\pchapsepmacro=\chapoddpage \global\let\pagealignmacro=\chapoddpage \global\def\HEADINGSon{\HEADINGSdouble}} \CHAPPAGon \def\CHAPFplain{ \global\let\chapmacro=\chfplain \global\let\unnumbchapmacro=\unnchfplain} \def\chfplain #1#2{% \pchapsepmacro {% \chapfonts \vbox{\hyphenpenalty=10000\tolerance=5000 \parindent=0pt\raggedright \rm #2\enspace #1}% }% \bigskip \penalty5000 } \def\unnchfplain #1{% \pchapsepmacro % {\chapfonts \vbox{\hyphenpenalty=10000\tolerance=5000 \parindent=0pt\raggedright \rm #1\hfill}}\bigskip \par\penalty 10000 % } \CHAPFplain % The default \def\unnchfopen #1{% \chapoddpage {\chapfonts \vbox{\hyphenpenalty=10000\tolerance=5000 \parindent=0pt\raggedright \rm #1\hfill}}\bigskip \par\penalty 10000 % } \def\chfopen #1#2{\chapoddpage {\chapfonts \vbox to 3in{\vfil \hbox to\hsize{\hfil #2} \hbox to\hsize{\hfil #1} \vfil}}% \par\penalty 5000 % } \def\CHAPFopen{ \global\let\chapmacro=\chfopen \global\let\unnumbchapmacro=\unnchfopen} % Parameter controlling skip before section headings. \newskip \subsecheadingskip \subsecheadingskip = 17pt plus 8pt minus 4pt \def\subsecheadingbreak{\dobreak \subsecheadingskip {-500}} \newskip \secheadingskip \secheadingskip = 21pt plus 8pt minus 4pt \def\secheadingbreak{\dobreak \secheadingskip {-1000}} % @paragraphindent is defined for the Info formatting commands only. \let\paragraphindent=\comment % Section fonts are the base font at magstep2, which produces % a size a bit more than 14 points in the default situation. \def\secheading #1#2#3{\secheadingi {#2.#3\enspace #1}} \def\plainsecheading #1{\secheadingi {#1}} \def\secheadingi #1{{\advance \secheadingskip by \parskip % \secheadingbreak}% {\secfonts \vbox{\hyphenpenalty=10000\tolerance=5000 \parindent=0pt\raggedright \rm #1\hfill}}% \ifdim \parskip<10pt \kern 10pt\kern -\parskip\fi \penalty 10000 } % Subsection fonts are the base font at magstep1, % which produces a size of 12 points. \def\subsecheading #1#2#3#4{\subsecheadingi {#2.#3.#4\enspace #1}} \def\subsecheadingi #1{{\advance \subsecheadingskip by \parskip % \subsecheadingbreak}% {\subsecfonts \vbox{\hyphenpenalty=10000\tolerance=5000 \parindent=0pt\raggedright \rm #1\hfill}}% \ifdim \parskip<10pt \kern 10pt\kern -\parskip\fi \penalty 10000 } \def\subsubsecfonts{\subsecfonts} % Maybe this should change: % Perhaps make sssec fonts scaled % magstep half \def\subsubsecheading #1#2#3#4#5{\subsubsecheadingi {#2.#3.#4.#5\enspace #1}} \def\subsubsecheadingi #1{{\advance \subsecheadingskip by \parskip % \subsecheadingbreak}% {\subsubsecfonts \vbox{\hyphenpenalty=10000\tolerance=5000 \parindent=0pt\raggedright \rm #1\hfill}}% \ifdim \parskip<10pt \kern 10pt\kern -\parskip\fi \penalty 10000} \message{toc printing,} % Finish up the main text and prepare to read what we've written % to \contentsfile. \newskip\contentsrightmargin \contentsrightmargin=1in \def\startcontents#1{% \pagealignmacro \immediate\closeout \contentsfile \ifnum \pageno>0 \pageno = -1 % Request roman numbered pages. \fi % Don't need to put `Contents' or `Short Contents' in the headline. % It is abundantly clear what they are. \unnumbchapmacro{#1}\def\thischapter{}% \begingroup % Set up to handle contents files properly. \catcode`\\=0 \catcode`\{=1 \catcode`\}=2 \catcode`\@=11 \catcode`\^=7 % to see ^^e4 as \"a etc. juha@piuha.ydi.vtt.fi \raggedbottom % Worry more about breakpoints than the bottom. \advance\hsize by -\contentsrightmargin % Don't use the full line length. } % Normal (long) toc. \outer\def\contents{% \startcontents{\putwordTableofContents}% \input \jobname.toc \endgroup \vfill \eject } % And just the chapters. \outer\def\summarycontents{% \startcontents{\putwordShortContents}% % \let\chapentry = \shortchapentry \let\unnumbchapentry = \shortunnumberedentry % We want a true roman here for the page numbers. \secfonts \let\rm=\shortcontrm \let\bf=\shortcontbf \let\sl=\shortcontsl \rm \advance\baselineskip by 1pt % Open it up a little. \def\secentry ##1##2##3##4{} \def\unnumbsecentry ##1##2{} \def\subsecentry ##1##2##3##4##5{} \def\unnumbsubsecentry ##1##2{} \def\subsubsecentry ##1##2##3##4##5##6{} \def\unnumbsubsubsecentry ##1##2{} \input \jobname.toc \endgroup \vfill \eject } \let\shortcontents = \summarycontents % These macros generate individual entries in the table of contents. % The first argument is the chapter or section name. % The last argument is the page number. % The arguments in between are the chapter number, section number, ... % Chapter-level things, for both the long and short contents. \def\chapentry#1#2#3{\dochapentry{#2\labelspace#1}{#3}} % See comments in \dochapentry re vbox and related settings \def\shortchapentry#1#2#3{% \tocentry{\shortchaplabel{#2}\labelspace #1}{\doshortpageno{#3}}% } % Typeset the label for a chapter or appendix for the short contents. % The arg is, e.g. `Appendix A' for an appendix, or `3' for a chapter. % We could simplify the code here by writing out an \appendixentry % command in the toc file for appendices, instead of using \chapentry % for both, but it doesn't seem worth it. \setbox0 = \hbox{\shortcontrm \putwordAppendix } \newdimen\shortappendixwidth \shortappendixwidth = \wd0 \def\shortchaplabel#1{% % We typeset #1 in a box of constant width, regardless of the text of % #1, so the chapter titles will come out aligned. \setbox0 = \hbox{#1}% \dimen0 = \ifdim\wd0 > \shortappendixwidth \shortappendixwidth \else 0pt \fi % % This space should be plenty, since a single number is .5em, and the % widest letter (M) is 1em, at least in the Computer Modern fonts. % (This space doesn't include the extra space that gets added after % the label; that gets put in in \shortchapentry above.) \advance\dimen0 by 1.1em \hbox to \dimen0{#1\hfil}% } \def\unnumbchapentry#1#2{\dochapentry{#1}{#2}} \def\shortunnumberedentry#1#2{\tocentry{#1}{\doshortpageno{#2}}} % Sections. \def\secentry#1#2#3#4{\dosecentry{#2.#3\labelspace#1}{#4}} \def\unnumbsecentry#1#2{\dosecentry{#1}{#2}} % Subsections. \def\subsecentry#1#2#3#4#5{\dosubsecentry{#2.#3.#4\labelspace#1}{#5}} \def\unnumbsubsecentry#1#2{\dosubsecentry{#1}{#2}} % And subsubsections. \def\subsubsecentry#1#2#3#4#5#6{% \dosubsubsecentry{#2.#3.#4.#5\labelspace#1}{#6}} \def\unnumbsubsubsecentry#1#2{\dosubsubsecentry{#1}{#2}} % This parameter controls the indentation of the various levels. \newdimen\tocindent \tocindent = 3pc % Now for the actual typesetting. In all these, #1 is the text and #2 is the % page number. % % If the toc has to be broken over pages, we would want to be at chapters % if at all possible; hence the \penalty. \def\dochapentry#1#2{% \penalty-300 \vskip\baselineskip \begingroup \chapentryfonts \tocentry{#1}{\dopageno{#2}}% \endgroup \nobreak\vskip .25\baselineskip } \def\dosecentry#1#2{\begingroup \secentryfonts \leftskip=\tocindent \tocentry{#1}{\dopageno{#2}}% \endgroup} \def\dosubsecentry#1#2{\begingroup \subsecentryfonts \leftskip=2\tocindent \tocentry{#1}{\dopageno{#2}}% \endgroup} \def\dosubsubsecentry#1#2{\begingroup \subsubsecentryfonts \leftskip=3\tocindent \tocentry{#1}{\dopageno{#2}}% \endgroup} % Final typesetting of a toc entry; we use the same \entry macro as for % the index entries, but we want to suppress hyphenation here. (We % can't do that in the \entry macro, since index entries might consist % of hyphenated-identifiers-that-do-not-fit-on-a-line-and-nothing-else.) % \def\tocentry#1#2{\begingroup \hyphenpenalty = 10000 \entry{#1}{#2}% \endgroup} % Space between chapter (or whatever) number and the title. \def\labelspace{\hskip1em \relax} \def\dopageno#1{{\rm #1}} \def\doshortpageno#1{{\rm #1}} \def\chapentryfonts{\secfonts \rm} \def\secentryfonts{\textfonts} \let\subsecentryfonts = \textfonts \let\subsubsecentryfonts = \textfonts \message{environments,} % Since these characters are used in examples, it should be an even number of % \tt widths. Each \tt character is 1en, so two makes it 1em. % Furthermore, these definitions must come after we define our fonts. \newbox\dblarrowbox \newbox\longdblarrowbox \newbox\pushcharbox \newbox\bullbox \newbox\equivbox \newbox\errorbox \let\ptexequiv = \equiv %{\tentt %\global\setbox\dblarrowbox = \hbox to 1em{\hfil$\Rightarrow$\hfil} %\global\setbox\longdblarrowbox = \hbox to 1em{\hfil$\mapsto$\hfil} %\global\setbox\pushcharbox = \hbox to 1em{\hfil$\dashv$\hfil} %\global\setbox\equivbox = \hbox to 1em{\hfil$\ptexequiv$\hfil} % Adapted from the manmac format (p.420 of TeXbook) %\global\setbox\bullbox = \hbox to 1em{\kern.15em\vrule height .75ex width .85ex % depth .1ex\hfil} %} \def\point{$\star$} \def\result{\leavevmode\raise.15ex\hbox to 1em{\hfil$\Rightarrow$\hfil}} \def\expansion{\leavevmode\raise.1ex\hbox to 1em{\hfil$\mapsto$\hfil}} \def\print{\leavevmode\lower.1ex\hbox to 1em{\hfil$\dashv$\hfil}} \def\equiv{\leavevmode\lower.1ex\hbox to 1em{\hfil$\ptexequiv$\hfil}} % Adapted from the TeXbook's \boxit. {\tentt \global\dimen0 = 3em}% Width of the box. \dimen2 = .55pt % Thickness of rules % The text. (`r' is open on the right, `e' somewhat less so on the left.) \setbox0 = \hbox{\kern-.75pt \tensf error\kern-1.5pt} \global\setbox\errorbox=\hbox to \dimen0{\hfil \hsize = \dimen0 \advance\hsize by -5.8pt % Space to left+right. \advance\hsize by -2\dimen2 % Rules. \vbox{ \hrule height\dimen2 \hbox{\vrule width\dimen2 \kern3pt % Space to left of text. \vtop{\kern2.4pt \box0 \kern2.4pt}% Space above/below. \kern3pt\vrule width\dimen2}% Space to right. \hrule height\dimen2} \hfil} % The @error{} command. \def\error{\leavevmode\lower.7ex\copy\errorbox} % @tex ... @end tex escapes into raw Tex temporarily. % One exception: @ is still an escape character, so that @end tex works. % But \@ or @@ will get a plain tex @ character. \def\tex{\begingroup \catcode `\\=0 \catcode `\{=1 \catcode `\}=2 \catcode `\$=3 \catcode `\&=4 \catcode `\#=6 \catcode `\^=7 \catcode `\_=8 \catcode `\~=13 \let~=\tie \catcode `\%=14 \catcode 43=12 \catcode`\"=12 \catcode`\==12 \catcode`\|=12 \catcode`\<=12 \catcode`\>=12 \escapechar=`\\ % \let\~=\ptextilde \let\{=\ptexlbrace \let\}=\ptexrbrace \let\.=\ptexdot \let\*=\ptexstar \let\dots=\ptexdots \def\@{@}% \let\bullet=\ptexbullet \let\b=\ptexb \let\c=\ptexc \let\i=\ptexi \let\t=\ptext \let\l=\ptexl \let\L=\ptexL % \let\Etex=\endgroup} % Define @lisp ... @endlisp. % @lisp does a \begingroup so it can rebind things, % including the definition of @endlisp (which normally is erroneous). % Amount to narrow the margins by for @lisp. \newskip\lispnarrowing \lispnarrowing=0.4in % This is the definition that ^^M gets inside @lisp, @example, and other % such environments. \null is better than a space, since it doesn't % have any width. \def\lisppar{\null\endgraf} % Make each space character in the input produce a normal interword % space in the output. Don't allow a line break at this space, as this % is used only in environments like @example, where each line of input % should produce a line of output anyway. % {\obeyspaces % \gdef\sepspaces{\obeyspaces\let =\tie}} % Define \obeyedspace to be our active space, whatever it is. This is % for use in \parsearg. {\sepspaces% \global\let\obeyedspace= } % This space is always present above and below environments. \newskip\envskipamount \envskipamount = 0pt % Make spacing and below environment symmetrical. We use \parskip here % to help in doing that, since in @example-like environments \parskip % is reset to zero; thus the \afterenvbreak inserts no space -- but the % start of the next paragraph will insert \parskip % \def\aboveenvbreak{{\advance\envskipamount by \parskip \endgraf \ifdim\lastskip<\envskipamount \removelastskip \penalty-50 \vskip\envskipamount \fi}} \let\afterenvbreak = \aboveenvbreak % \nonarrowing is a flag. If "set", @lisp etc don't narrow margins. \let\nonarrowing=\relax %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % \cartouche: draw rectangle w/rounded corners around argument \font\circle=lcircle10 \newdimen\circthick \newdimen\cartouter\newdimen\cartinner \newskip\normbskip\newskip\normpskip\newskip\normlskip \circthick=\fontdimen8\circle % \def\ctl{{\circle\char'013\hskip -6pt}}% 6pt from pl file: 1/2charwidth \def\ctr{{\hskip 6pt\circle\char'010}} \def\cbl{{\circle\char'012\hskip -6pt}} \def\cbr{{\hskip 6pt\circle\char'011}} \def\carttop{\hbox to \cartouter{\hskip\lskip \ctl\leaders\hrule height\circthick\hfil\ctr \hskip\rskip}} \def\cartbot{\hbox to \cartouter{\hskip\lskip \cbl\leaders\hrule height\circthick\hfil\cbr \hskip\rskip}} % \newskip\lskip\newskip\rskip \long\def\cartouche{% \begingroup \lskip=\leftskip \rskip=\rightskip \leftskip=0pt\rightskip=0pt %we want these *outside*. \cartinner=\hsize \advance\cartinner by-\lskip \advance\cartinner by-\rskip \cartouter=\hsize \advance\cartouter by 18pt % allow for 3pt kerns on either % side, and for 6pt waste from % each corner char \normbskip=\baselineskip \normpskip=\parskip \normlskip=\lineskip % Flag to tell @lisp, etc., not to narrow margin. \let\nonarrowing=\comment \vbox\bgroup \baselineskip=0pt\parskip=0pt\lineskip=0pt \carttop \hbox\bgroup \hskip\lskip \vrule\kern3pt \vbox\bgroup \hsize=\cartinner \kern3pt \begingroup \baselineskip=\normbskip \lineskip=\normlskip \parskip=\normpskip \vskip -\parskip \def\Ecartouche{% \endgroup \kern3pt \egroup \kern3pt\vrule \hskip\rskip \egroup \cartbot \egroup \endgroup }} % This macro is called at the beginning of all the @example variants, % inside a group. \def\nonfillstart{% \aboveenvbreak \inENV % This group ends at the end of the body \hfuzz = 12pt % Don't be fussy \sepspaces % Make spaces be word-separators rather than space tokens. \singlespace \let\par = \lisppar % don't ignore blank lines \obeylines % each line of input is a line of output \parskip = 0pt \parindent = 0pt \emergencystretch = 0pt % don't try to avoid overfull boxes % @cartouche defines \nonarrowing to inhibit narrowing % at next level down. \ifx\nonarrowing\relax \advance \leftskip by \lispnarrowing \exdentamount=\lispnarrowing \let\exdent=\nofillexdent \let\nonarrowing=\relax \fi } % To ending an @example-like environment, we first end the paragraph % (via \afterenvbreak's vertical glue), and then the group. That way we % keep the zero \parskip that the environments set -- \parskip glue % will be inserted at the beginning of the next paragraph in the % document, after the environment. % \def\nonfillfinish{\afterenvbreak\endgroup}% % This macro is \def\lisp{\begingroup \nonfillstart \let\Elisp = \nonfillfinish \tt \rawbackslash % have \ input char produce \ char from current font \gobble } % Define the \E... control sequence only if we are inside the % environment, so the error checking in \end will work. % % We must call \lisp last in the definition, since it reads the % return following the @example (or whatever) command. % \def\example{\begingroup \def\Eexample{\nonfillfinish\endgroup}\lisp} \def\smallexample{\begingroup \def\Esmallexample{\nonfillfinish\endgroup}\lisp} \def\smalllisp{\begingroup \def\Esmalllisp{\nonfillfinish\endgroup}\lisp} % @smallexample and @smalllisp. This is not used unless the @smallbook % command is given. Originally contributed by Pavel@xerox. % \def\smalllispx{\begingroup \nonfillstart \let\Esmalllisp = \nonfillfinish \let\Esmallexample = \nonfillfinish % % Smaller interline space and fonts for small examples. \setleading{10pt}% \indexfonts \tt \rawbackslash % make \ output the \ character from the current font (tt) \gobble } % This is @display; same as @lisp except use roman font. % \def\display{\begingroup \nonfillstart \let\Edisplay = \nonfillfinish \gobble } % This is @format; same as @display except don't narrow margins. % \def\format{\begingroup \let\nonarrowing = t \nonfillstart \let\Eformat = \nonfillfinish \gobble } % @flushleft (same as @format) and @flushright. % \def\flushleft{\begingroup \let\nonarrowing = t \nonfillstart \let\Eflushleft = \nonfillfinish \gobble } \def\flushright{\begingroup \let\nonarrowing = t \nonfillstart \let\Eflushright = \nonfillfinish \advance\leftskip by 0pt plus 1fill \gobble} % @quotation does normal linebreaking (hence we can't use \nonfillstart) % and narrows the margins. % \def\quotation{% \begingroup\inENV %This group ends at the end of the @quotation body {\parskip=0pt \aboveenvbreak}% because \aboveenvbreak inserts \parskip \singlespace \parindent=0pt % We have retained a nonzero parskip for the environment, since we're % doing normal filling. So to avoid extra space below the environment... \def\Equotation{\parskip = 0pt \nonfillfinish}% % % @cartouche defines \nonarrowing to inhibit narrowing at next level down. \ifx\nonarrowing\relax \advance\leftskip by \lispnarrowing \advance\rightskip by \lispnarrowing \exdentamount = \lispnarrowing \let\nonarrowing = \relax \fi } \message{defuns,} % Define formatter for defuns % First, allow user to change definition object font (\df) internally \def\setdeffont #1 {\csname DEF#1\endcsname} \newskip\defbodyindent \defbodyindent=.4in \newskip\defargsindent \defargsindent=50pt \newskip\deftypemargin \deftypemargin=12pt \newskip\deflastargmargin \deflastargmargin=18pt \newcount\parencount % define \functionparens, which makes ( and ) and & do special things. % \functionparens affects the group it is contained in. \def\activeparens{% \catcode`\(=\active \catcode`\)=\active \catcode`\&=\active \catcode`\[=\active \catcode`\]=\active} % Make control sequences which act like normal parenthesis chars. \let\lparen = ( \let\rparen = ) {\activeparens % Now, smart parens don't turn on until &foo (see \amprm) % Be sure that we always have a definition for `(', etc. For example, % if the fn name has parens in it, \boldbrax will not be in effect yet, % so TeX would otherwise complain about undefined control sequence. \global\let(=\lparen \global\let)=\rparen \global\let[=\lbrack \global\let]=\rbrack \gdef\functionparens{\boldbrax\let&=\amprm\parencount=0 } \gdef\boldbrax{\let(=\opnr\let)=\clnr\let[=\lbrb\let]=\rbrb} % This is used to turn on special parens % but make & act ordinary (given that it's active). \gdef\boldbraxnoamp{\let(=\opnr\let)=\clnr\let[=\lbrb\let]=\rbrb\let&=\ampnr} % Definitions of (, ) and & used in args for functions. % This is the definition of ( outside of all parentheses. \gdef\oprm#1 {{\rm\char`\(}#1 \bf \let(=\opnested % \global\advance\parencount by 1 } % % This is the definition of ( when already inside a level of parens. \gdef\opnested{\char`\(\global\advance\parencount by 1 } % \gdef\clrm{% Print a paren in roman if it is taking us back to depth of 0. % also in that case restore the outer-level definition of (. \ifnum \parencount=1 {\rm \char `\)}\sl \let(=\oprm \else \char `\) \fi \global\advance \parencount by -1 } % If we encounter &foo, then turn on ()-hacking afterwards \gdef\amprm#1 {{\rm\}\let(=\oprm \let)=\clrm\ } % \gdef\normalparens{\boldbrax\let&=\ampnr} } % End of definition inside \activeparens %% These parens (in \boldbrax) actually are a little bolder than the %% contained text. This is especially needed for [ and ] \def\opnr{{\sf\char`\(}} \def\clnr{{\sf\char`\)}} \def\ampnr{\&} \def\lbrb{{\bf\char`\[}} \def\rbrb{{\bf\char`\]}} % First, defname, which formats the header line itself. % #1 should be the function name. % #2 should be the type of definition, such as "Function". \def\defname #1#2{% % Get the values of \leftskip and \rightskip as they were % outside the @def... \dimen2=\leftskip \advance\dimen2 by -\defbodyindent \dimen3=\rightskip \advance\dimen3 by -\defbodyindent \noindent % \setbox0=\hbox{\hskip \deflastargmargin{\rm #2}\hskip \deftypemargin}% \dimen0=\hsize \advance \dimen0 by -\wd0 % compute size for first line \dimen1=\hsize \advance \dimen1 by -\defargsindent %size for continuations \parshape 2 0in \dimen0 \defargsindent \dimen1 % % Now output arg 2 ("Function" or some such) % ending at \deftypemargin from the right margin, % but stuck inside a box of width 0 so it does not interfere with linebreaking {% Adjust \hsize to exclude the ambient margins, % so that \rightline will obey them. \advance \hsize by -\dimen2 \advance \hsize by -\dimen3 \rlap{\rightline{{\rm #2}\hskip \deftypemargin}}}% % Make all lines underfull and no complaints: \tolerance=10000 \hbadness=10000 \advance\leftskip by -\defbodyindent \exdentamount=\defbodyindent {\df #1}\enskip % Generate function name } % Actually process the body of a definition % #1 should be the terminating control sequence, such as \Edefun. % #2 should be the "another name" control sequence, such as \defunx. % #3 should be the control sequence that actually processes the header, % such as \defunheader. \def\defparsebody #1#2#3{\begingroup\inENV% Environment for definitionbody \medbreak % % Define the end token that this defining construct specifies % so that it will exit this group. \def#1{\endgraf\endgroup\medbreak}% \def#2{\begingroup\obeylines\activeparens\spacesplit#3}% \parindent=0in \advance\leftskip by \defbodyindent \advance \rightskip by \defbodyindent \exdentamount=\defbodyindent \begingroup % \catcode 61=\active % 61 is `=' \obeylines\activeparens\spacesplit#3} \def\defmethparsebody #1#2#3#4 {\begingroup\inENV % \medbreak % % Define the end token that this defining construct specifies % so that it will exit this group. \def#1{\endgraf\endgroup\medbreak}% \def#2##1 {\begingroup\obeylines\activeparens\spacesplit{#3{##1}}}% \parindent=0in \advance\leftskip by \defbodyindent \advance \rightskip by \defbodyindent \exdentamount=\defbodyindent \begingroup\obeylines\activeparens\spacesplit{#3{#4}}} \def\defopparsebody #1#2#3#4#5 {\begingroup\inENV % \medbreak % % Define the end token that this defining construct specifies % so that it will exit this group. \def#1{\endgraf\endgroup\medbreak}% \def#2##1 ##2 {\def#4{##1}% \begingroup\obeylines\activeparens\spacesplit{#3{##2}}}% \parindent=0in \advance\leftskip by \defbodyindent \advance \rightskip by \defbodyindent \exdentamount=\defbodyindent \begingroup\obeylines\activeparens\spacesplit{#3{#5}}} % These parsing functions are similar to the preceding ones % except that they do not make parens into active characters. % These are used for "variables" since they have no arguments. \def\defvarparsebody #1#2#3{\begingroup\inENV% Environment for definitionbody \medbreak % % Define the end token that this defining construct specifies % so that it will exit this group. \def#1{\endgraf\endgroup\medbreak}% \def#2{\begingroup\obeylines\spacesplit#3}% \parindent=0in \advance\leftskip by \defbodyindent \advance \rightskip by \defbodyindent \exdentamount=\defbodyindent \begingroup % \catcode 61=\active % \obeylines\spacesplit#3} % This is used for \def{tp,vr}parsebody. It could probably be used for % some of the others, too, with some judicious conditionals. % \def\parsebodycommon#1#2#3{% \begingroup\inENV % \medbreak % % Define the end token that this defining construct specifies % so that it will exit this group. \def#1{\endgraf\endgroup\medbreak}% \def#2##1 {\begingroup\obeylines\spacesplit{#3{##1}}}% \parindent=0in \advance\leftskip by \defbodyindent \advance \rightskip by \defbodyindent \exdentamount=\defbodyindent \begingroup\obeylines } \def\defvrparsebody#1#2#3#4 {% \parsebodycommon{#1}{#2}{#3}% \spacesplit{#3{#4}}% } % This loses on `@deftp {Data Type} {struct termios}' -- it thinks the % type is just `struct', because we lose the braces in `{struct % termios}' when \spacesplit reads its undelimited argument. Sigh. % \let\deftpparsebody=\defvrparsebody % % So, to get around this, we put \empty in with the type name. That % way, TeX won't find exactly `{...}' as an undelimited argument, and % won't strip off the braces. % \def\deftpparsebody #1#2#3#4 {% \parsebodycommon{#1}{#2}{#3}% \spacesplit{\parsetpheaderline{#3{#4}}}\empty } % Fine, but then we have to eventually remove the \empty *and* the % braces (if any). That's what this does, putting the result in \tptemp. % \def\removeemptybraces\empty#1\relax{\def\tptemp{#1}}% % After \spacesplit has done its work, this is called -- #1 is the final % thing to call, #2 the type name (which starts with \empty), and #3 % (which might be empty) the arguments. % \def\parsetpheaderline#1#2#3{% \removeemptybraces#2\relax #1{\tptemp}{#3}% }% \def\defopvarparsebody #1#2#3#4#5 {\begingroup\inENV % \medbreak % % Define the end token that this defining construct specifies % so that it will exit this group. \def#1{\endgraf\endgroup\medbreak}% \def#2##1 ##2 {\def#4{##1}% \begingroup\obeylines\spacesplit{#3{##2}}}% \parindent=0in \advance\leftskip by \defbodyindent \advance \rightskip by \defbodyindent \exdentamount=\defbodyindent \begingroup\obeylines\spacesplit{#3{#5}}} % Split up #2 at the first space token. % call #1 with two arguments: % the first is all of #2 before the space token, % the second is all of #2 after that space token. % If #2 contains no space token, all of it is passed as the first arg % and the second is passed as empty. {\obeylines \gdef\spacesplit#1#2^^M{\endgroup\spacesplitfoo{#1}#2 \relax\spacesplitfoo}% \long\gdef\spacesplitfoo#1#2 #3#4\spacesplitfoo{% \ifx\relax #3% #1{#2}{}\else #1{#2}{#3#4}\fi}} % So much for the things common to all kinds of definitions. % Define @defun. % First, define the processing that is wanted for arguments of \defun % Use this to expand the args and terminate the paragraph they make up \def\defunargs #1{\functionparens \sl % Expand, preventing hyphenation at `-' chars. % Note that groups don't affect changes in \hyphenchar. \hyphenchar\tensl=0 #1% \hyphenchar\tensl=45 \ifnum\parencount=0 \else \errmessage{unbalanced parens in @def arguments}\fi% \interlinepenalty=10000 \advance\rightskip by 0pt plus 1fil \endgraf\penalty 10000\vskip -\parskip\penalty 10000% } \def\deftypefunargs #1{% % Expand, preventing hyphenation at `-' chars. % Note that groups don't affect changes in \hyphenchar. % Use \boldbraxnoamp, not \functionparens, so that & is not special. \boldbraxnoamp \tclose{#1}% avoid \code because of side effects on active chars \interlinepenalty=10000 \advance\rightskip by 0pt plus 1fil \endgraf\penalty 10000\vskip -\parskip\penalty 10000% } % Do complete processing of one @defun or @defunx line already parsed. % @deffn Command forward-char nchars \def\deffn{\defmethparsebody\Edeffn\deffnx\deffnheader} \def\deffnheader #1#2#3{\doind {fn}{\code{#2}}% \begingroup\defname {#2}{#1}\defunargs{#3}\endgroup % \catcode 61=\other % Turn off change made in \defparsebody } % @defun == @deffn Function \def\defun{\defparsebody\Edefun\defunx\defunheader} \def\defunheader #1#2{\doind {fn}{\code{#1}}% Make entry in function index \begingroup\defname {#1}{Function}% \defunargs {#2}\endgroup % \catcode 61=\other % Turn off change made in \defparsebody } % @deftypefun int foobar (int @var{foo}, float @var{bar}) \def\deftypefun{\defparsebody\Edeftypefun\deftypefunx\deftypefunheader} % #1 is the data type. #2 is the name and args. \def\deftypefunheader #1#2{\deftypefunheaderx{#1}#2 \relax} % #1 is the data type, #2 the name, #3 the args. \def\deftypefunheaderx #1#2 #3\relax{% \doind {fn}{\code{#2}}% Make entry in function index \begingroup\defname {\defheaderxcond#1\relax$$$#2}{Function}% \deftypefunargs {#3}\endgroup % \catcode 61=\other % Turn off change made in \defparsebody } % @deftypefn {Library Function} int foobar (int @var{foo}, float @var{bar}) \def\deftypefn{\defmethparsebody\Edeftypefn\deftypefnx\deftypefnheader} % \defheaderxcond#1\relax$$$ % puts #1 in @code, followed by a space, but does nothing if #1 is null. \def\defheaderxcond#1#2$$${\ifx#1\relax\else\code{#1#2} \fi} % #1 is the classification. #2 is the data type. #3 is the name and args. \def\deftypefnheader #1#2#3{\deftypefnheaderx{#1}{#2}#3 \relax} % #1 is the classification, #2 the data type, #3 the name, #4 the args. \def\deftypefnheaderx #1#2#3 #4\relax{% \doind {fn}{\code{#3}}% Make entry in function index \begingroup \normalparens % notably, turn off `&' magic, which prevents % at least some C++ text from working \defname {\defheaderxcond#2\relax$$$#3}{#1}% \deftypefunargs {#4}\endgroup % \catcode 61=\other % Turn off change made in \defparsebody } % @defmac == @deffn Macro \def\defmac{\defparsebody\Edefmac\defmacx\defmacheader} \def\defmacheader #1#2{\doind {fn}{\code{#1}}% Make entry in function index \begingroup\defname {#1}{Macro}% \defunargs {#2}\endgroup % \catcode 61=\other % Turn off change made in \defparsebody } % @defspec == @deffn Special Form \def\defspec{\defparsebody\Edefspec\defspecx\defspecheader} \def\defspecheader #1#2{\doind {fn}{\code{#1}}% Make entry in function index \begingroup\defname {#1}{Special Form}% \defunargs {#2}\endgroup % \catcode 61=\other % Turn off change made in \defparsebody } % This definition is run if you use @defunx % anywhere other than immediately after a @defun or @defunx. \def\deffnx #1 {\errmessage{@deffnx in invalid context}} \def\defunx #1 {\errmessage{@defunx in invalid context}} \def\defmacx #1 {\errmessage{@defmacx in invalid context}} \def\defspecx #1 {\errmessage{@defspecx in invalid context}} \def\deftypefnx #1 {\errmessage{@deftypefnx in invalid context}} \def\deftypeunx #1 {\errmessage{@deftypeunx in invalid context}} % @defmethod, and so on % @defop {Funny Method} foo-class frobnicate argument \def\defop #1 {\def\defoptype{#1}% \defopparsebody\Edefop\defopx\defopheader\defoptype} \def\defopheader #1#2#3{% \dosubind {fn}{\code{#2}}{on #1}% Make entry in function index \begingroup\defname {#2}{\defoptype{} on #1}% \defunargs {#3}\endgroup % } % @defmethod == @defop Method \def\defmethod{\defmethparsebody\Edefmethod\defmethodx\defmethodheader} \def\defmethodheader #1#2#3{% \dosubind {fn}{\code{#2}}{on #1}% entry in function index \begingroup\defname {#2}{Method on #1}% \defunargs {#3}\endgroup % } % @defcv {Class Option} foo-class foo-flag \def\defcv #1 {\def\defcvtype{#1}% \defopvarparsebody\Edefcv\defcvx\defcvarheader\defcvtype} \def\defcvarheader #1#2#3{% \dosubind {vr}{\code{#2}}{of #1}% Make entry in var index \begingroup\defname {#2}{\defcvtype{} of #1}% \defvarargs {#3}\endgroup % } % @defivar == @defcv {Instance Variable} \def\defivar{\defvrparsebody\Edefivar\defivarx\defivarheader} \def\defivarheader #1#2#3{% \dosubind {vr}{\code{#2}}{of #1}% Make entry in var index \begingroup\defname {#2}{Instance Variable of #1}% \defvarargs {#3}\endgroup % } % These definitions are run if you use @defmethodx, etc., % anywhere other than immediately after a @defmethod, etc. \def\defopx #1 {\errmessage{@defopx in invalid context}} \def\defmethodx #1 {\errmessage{@defmethodx in invalid context}} \def\defcvx #1 {\errmessage{@defcvx in invalid context}} \def\defivarx #1 {\errmessage{@defivarx in invalid context}} % Now @defvar % First, define the processing that is wanted for arguments of @defvar. % This is actually simple: just print them in roman. % This must expand the args and terminate the paragraph they make up \def\defvarargs #1{\normalparens #1% \interlinepenalty=10000 \endgraf\penalty 10000\vskip -\parskip\penalty 10000} % @defvr Counter foo-count \def\defvr{\defvrparsebody\Edefvr\defvrx\defvrheader} \def\defvrheader #1#2#3{\doind {vr}{\code{#2}}% \begingroup\defname {#2}{#1}\defvarargs{#3}\endgroup} % @defvar == @defvr Variable \def\defvar{\defvarparsebody\Edefvar\defvarx\defvarheader} \def\defvarheader #1#2{\doind {vr}{\code{#1}}% Make entry in var index \begingroup\defname {#1}{Variable}% \defvarargs {#2}\endgroup % } % @defopt == @defvr {User Option} \def\defopt{\defvarparsebody\Edefopt\defoptx\defoptheader} \def\defoptheader #1#2{\doind {vr}{\code{#1}}% Make entry in var index \begingroup\defname {#1}{User Option}% \defvarargs {#2}\endgroup % } % @deftypevar int foobar \def\deftypevar{\defvarparsebody\Edeftypevar\deftypevarx\deftypevarheader} % #1 is the data type. #2 is the name. \def\deftypevarheader #1#2{% \doind {vr}{\code{#2}}% Make entry in variables index \begingroup\defname {\defheaderxcond#1\relax$$$#2}{Variable}% \interlinepenalty=10000 \endgraf\penalty 10000\vskip -\parskip\penalty 10000 \endgroup} % @deftypevr {Global Flag} int enable \def\deftypevr{\defvrparsebody\Edeftypevr\deftypevrx\deftypevrheader} \def\deftypevrheader #1#2#3{\doind {vr}{\code{#3}}% \begingroup\defname {\defheaderxcond#2\relax$$$#3}{#1} \interlinepenalty=10000 \endgraf\penalty 10000\vskip -\parskip\penalty 10000 \endgroup} % This definition is run if you use @defvarx % anywhere other than immediately after a @defvar or @defvarx. \def\defvrx #1 {\errmessage{@defvrx in invalid context}} \def\defvarx #1 {\errmessage{@defvarx in invalid context}} \def\defoptx #1 {\errmessage{@defoptx in invalid context}} \def\deftypevarx #1 {\errmessage{@deftypevarx in invalid context}} \def\deftypevrx #1 {\errmessage{@deftypevrx in invalid context}} % Now define @deftp % Args are printed in bold, a slight difference from @defvar. \def\deftpargs #1{\bf \defvarargs{#1}} % @deftp Class window height width ... \def\deftp{\deftpparsebody\Edeftp\deftpx\deftpheader} \def\deftpheader #1#2#3{\doind {tp}{\code{#2}}% \begingroup\defname {#2}{#1}\deftpargs{#3}\endgroup} % This definition is run if you use @deftpx, etc % anywhere other than immediately after a @deftp, etc. \def\deftpx #1 {\errmessage{@deftpx in invalid context}} \message{cross reference,} % Define cross-reference macros \newwrite \auxfile \newif\ifhavexrefs % True if xref values are known. \newif\ifwarnedxrefs % True if we warned once that they aren't known. % \setref{foo} defines a cross-reference point named foo. \def\setref#1{% \dosetq{#1-title}{Ytitle}% \dosetq{#1-pg}{Ypagenumber}% \dosetq{#1-snt}{Ysectionnumberandtype}} \def\unnumbsetref#1{% \dosetq{#1-title}{Ytitle}% \dosetq{#1-pg}{Ypagenumber}% \dosetq{#1-snt}{Ynothing}} \def\appendixsetref#1{% \dosetq{#1-title}{Ytitle}% \dosetq{#1-pg}{Ypagenumber}% \dosetq{#1-snt}{Yappendixletterandtype}} % \xref, \pxref, and \ref generate cross-references to specified points. % For \xrefX, #1 is the node name, #2 the name of the Info % cross-reference, #3 the printed node name, #4 the name of the Info % file, #5 the name of the printed manual. All but the node name can be % omitted. % \def\pxref#1{\putwordsee{} \xrefX[#1,,,,,,,]} \def\xref#1{\putwordSee{} \xrefX[#1,,,,,,,]} \def\ref#1{\xrefX[#1,,,,,,,]} \def\xrefX[#1,#2,#3,#4,#5,#6]{\begingroup \def\printedmanual{\ignorespaces #5}% \def\printednodename{\ignorespaces #3}% \setbox1=\hbox{\printedmanual}% \setbox0=\hbox{\printednodename}% \ifdim \wd0 = 0pt % No printed node name was explicitly given. \ifx\SETxref-automatic-section-title\relax % % Use the actual chapter/section title appear inside % the square brackets. Use the real section title if we have it. \ifdim \wd1>0pt% % It is in another manual, so we don't have it. \def\printednodename{\ignorespaces #1}% \else \ifhavexrefs % We know the real title if we have the xref values. \def\printednodename{\refx{#1-title}}% \else % Otherwise just copy the Info node name. \def\printednodename{\ignorespaces #1}% \fi% \fi \def\printednodename{#1-title}% \else % Use the node name inside the square brackets. \def\printednodename{\ignorespaces #1}% \fi \fi % % If we use \unhbox0 and \unhbox1 to print the node names, TeX does not % insert empty discretionaries after hyphens, which means that it will % not find a line break at a hyphen in a node names. Since some manuals % are best written with fairly long node names, containing hyphens, this % is a loss. Therefore, we give the text of the node name again, so it % is as if TeX is seeing it for the first time. \ifdim \wd1 > 0pt \putwordsection{} ``\printednodename'' in \cite{\printedmanual}% \else % _ (for example) has to be the character _ for the purposes of the % control sequence corresponding to the node, but it has to expand % into the usual \leavevmode...\vrule stuff for purposes of % printing. So we \turnoffactive for the \refx-snt, back on for the % printing, back off for the \refx-pg. {\turnoffactive \refx{#1-snt}{}}% \space [\printednodename],\space \turnoffactive \putwordpage\tie\refx{#1-pg}{}% \fi \endgroup} % \dosetq is the interface for calls from other macros % Use \turnoffactive so that punctuation chars such as underscore % work in node names. \def\dosetq #1#2{{\let\folio=0 \turnoffactive \auxhat% \edef\next{\write\auxfile{\internalsetq {#1}{#2}}}% \next}} % \internalsetq {foo}{page} expands into % CHARACTERS 'xrdef {foo}{...expansion of \Ypage...} % When the aux file is read, ' is the escape character \def\internalsetq #1#2{'xrdef {#1}{\csname #2\endcsname}} % Things to be expanded by \internalsetq \def\Ypagenumber{\folio} \def\Ytitle{\thissection} \def\Ynothing{} \def\Ysectionnumberandtype{% \ifnum\secno=0 \putwordChapter\xreftie\the\chapno % \else \ifnum \subsecno=0 \putwordSection\xreftie\the\chapno.\the\secno % \else \ifnum \subsubsecno=0 % \putwordSection\xreftie\the\chapno.\the\secno.\the\subsecno % \else % \putwordSection\xreftie\the\chapno.\the\secno.\the\subsecno.\the\subsubsecno % \fi \fi \fi } \def\Yappendixletterandtype{% \ifnum\secno=0 \putwordAppendix\xreftie'char\the\appendixno{}% \else \ifnum \subsecno=0 \putwordSection\xreftie'char\the\appendixno.\the\secno % \else \ifnum \subsubsecno=0 % \putwordSection\xreftie'char\the\appendixno.\the\secno.\the\subsecno % \else % \putwordSection\xreftie'char\the\appendixno.\the\secno.\the\subsecno.\the\subsubsecno % \fi \fi \fi } \gdef\xreftie{'tie} % Use TeX 3.0's \inputlineno to get the line number, for better error % messages, but if we're using an old version of TeX, don't do anything. % \ifx\inputlineno\thisisundefined \let\linenumber = \empty % Non-3.0. \else \def\linenumber{\the\inputlineno:\space} \fi % Define \refx{NAME}{SUFFIX} to reference a cross-reference string named NAME. % If its value is nonempty, SUFFIX is output afterward. \def\refx#1#2{% \expandafter\ifx\csname X#1\endcsname\relax % If not defined, say something at least. $\langle$un\-de\-fined$\rangle$% \ifhavexrefs \message{\linenumber Undefined cross reference `#1'.}% \else \ifwarnedxrefs\else \global\warnedxrefstrue \message{Cross reference values unknown; you must run TeX again.}% \fi \fi \else % It's defined, so just use it. \csname X#1\endcsname \fi #2% Output the suffix in any case. } % Read the last existing aux file, if any. No error if none exists. % This is the macro invoked by entries in the aux file. \def\xrdef #1#2{ {\catcode`\'=\other\expandafter \gdef \csname X#1\endcsname {#2}}} \def\readauxfile{% \begingroup \catcode `\^^@=\other \catcode `\=\other \catcode `\=\other \catcode `\^^C=\other \catcode `\^^D=\other \catcode `\^^E=\other \catcode `\^^F=\other \catcode `\^^G=\other \catcode `\^^H=\other \catcode `\ =\other \catcode `\^^L=\other \catcode `\=\other \catcode `\=\other \catcode `\=\other \catcode `\=\other \catcode `\=\other \catcode `\=\other \catcode `\=\other \catcode `\=\other \catcode `\=\other \catcode `\=\other \catcode `\=\other \catcode `\=\other \catcode 26=\other \catcode `\^^[=\other \catcode `\^^\=\other \catcode `\^^]=\other \catcode `\^^^=\other \catcode `\^^_=\other \catcode `\@=\other \catcode `\^=\other \catcode `\~=\other \catcode `\[=\other \catcode `\]=\other \catcode`\"=\other \catcode`\_=\other \catcode`\|=\other \catcode`\<=\other \catcode`\>=\other \catcode `\$=\other \catcode `\#=\other \catcode `\&=\other % `\+ does not work, so use 43. \catcode 43=\other % Make the characters 128-255 be printing characters {% \count 1=128 \def\loop{% \catcode\count 1=\other \advance\count 1 by 1 \ifnum \count 1<256 \loop \fi }% }% % the aux file uses ' as the escape. % Turn off \ as an escape so we do not lose on % entries which were dumped with control sequences in their names. % For example, 'xrdef {$\leq $-fun}{page ...} made by @defun ^^ % Reference to such entries still does not work the way one would wish, % but at least they do not bomb out when the aux file is read in. \catcode `\{=1 \catcode `\}=2 \catcode `\%=\other \catcode `\'=0 \catcode`\^=7 % to make ^^e4 etc usable in xref tags \catcode `\\=\other \openin 1 \jobname.aux \ifeof 1 \else \closein 1 \input \jobname.aux \global\havexrefstrue \global\warnedobstrue \fi % Open the new aux file. Tex will close it automatically at exit. \openout \auxfile=\jobname.aux \endgroup} % Footnotes. \newcount \footnoteno % The trailing space in the following definition for supereject is % vital for proper filling; pages come out unaligned when you do a % pagealignmacro call if that space before the closing brace is % removed. \def\supereject{\par\penalty -20000\footnoteno =0 } % @footnotestyle is meaningful for info output only.. \let\footnotestyle=\comment \let\ptexfootnote=\footnote {\catcode `\@=11 % % Auto-number footnotes. Otherwise like plain. \gdef\footnote{% \global\advance\footnoteno by \@ne \edef\thisfootno{$^{\the\footnoteno}$}% % % In case the footnote comes at the end of a sentence, preserve the % extra spacing after we do the footnote number. \let\@sf\empty \ifhmode\edef\@sf{\spacefactor\the\spacefactor}\/\fi % % Remove inadvertent blank space before typesetting the footnote number. \unskip \thisfootno\@sf \footnotezzz }% % Don't bother with the trickery in plain.tex to not require the % footnote text as a parameter. Our footnotes don't need to be so general. % \long\gdef\footnotezzz#1{\insert\footins{% % We want to typeset this text as a normal paragraph, even if the % footnote reference occurs in (for example) a display environment. % So reset some parameters. \interlinepenalty\interfootnotelinepenalty \splittopskip\ht\strutbox % top baseline for broken footnotes \splitmaxdepth\dp\strutbox \floatingpenalty\@MM \leftskip\z@skip \rightskip\z@skip \spaceskip\z@skip \xspaceskip\z@skip \parindent\defaultparindent % % Hang the footnote text off the number. \hang \textindent{\thisfootno}% % % Don't crash into the line above the footnote text. Since this % expands into a box, it must come within the paragraph, lest it % provide a place where TeX can split the footnote. \footstrut #1\strut}% } }%end \catcode `\@=11 % Set the baselineskip to #1, and the lineskip and strut size % correspondingly. There is no deep meaning behind these magic numbers % used as factors; they just match (closely enough) what Knuth defined. % \def\lineskipfactor{.08333} \def\strutheightpercent{.70833} \def\strutdepthpercent {.29167} % \def\setleading#1{% \normalbaselineskip = #1\relax \normallineskip = \lineskipfactor\normalbaselineskip \normalbaselines \setbox\strutbox =\hbox{% \vrule width0pt height\strutheightpercent\baselineskip depth \strutdepthpercent \baselineskip }% } % @| inserts a changebar to the left of the current line. It should % surround any changed text. This approach does *not* work if the % change spans more than two lines of output. To handle that, we would % have adopt a much more difficult approach (putting marks into the main % vertical list for the beginning and end of each change). % \def\|{% % \vadjust can only be used in horizontal mode. \leavevmode % % Append this vertical mode material after the current line in the output. \vadjust{% % We want to insert a rule with the height and depth of the current % leading; that is exactly what \strutbox is supposed to record. \vskip-\baselineskip % % \vadjust-items are inserted at the left edge of the type. So % the \llap here moves out into the left-hand margin. \llap{% % % For a thicker or thinner bar, change the `1pt'. \vrule height\baselineskip width1pt % % This is the space between the bar and the text. \hskip 12pt }% }% } % For a final copy, take out the rectangles % that mark overfull boxes (in case you have decided % that the text looks ok even though it passes the margin). % \def\finalout{\overfullrule=0pt} % End of control word definitions. \message{and turning on texinfo input format.} \def\openindices{% \newindex{cp}% \newcodeindex{fn}% \newcodeindex{vr}% \newcodeindex{tp}% \newcodeindex{ky}% \newcodeindex{pg}% } % Set some numeric style parameters, for 8.5 x 11 format. %\hsize = 6.5in \newdimen\defaultparindent \defaultparindent = 15pt \parindent = \defaultparindent \parskip 18pt plus 1pt \setleading{15pt} \advance\topskip by 1.2cm % Prevent underfull vbox error messages. \vbadness=10000 % Following George Bush, just get rid of widows and orphans. \widowpenalty=10000 \clubpenalty=10000 % Use TeX 3.0's \emergencystretch to help line breaking, but if we're % using an old version of TeX, don't do anything. We want the amount of % stretch added to depend on the line length, hence the dependence on % \hsize. This makes it come to about 9pt for the 8.5x11 format. % \ifx\emergencystretch\thisisundefined % Allow us to assign to \emergencystretch anyway. \def\emergencystretch{\dimen0}% \else \emergencystretch = \hsize \divide\emergencystretch by 45 \fi % Use @smallbook to reset parameters for 7x9.5 format (or else 7x9.25) \def\smallbook{ % These values for secheadingskip and subsecheadingskip are % experiments. RJC 7 Aug 1992 \global\secheadingskip = 17pt plus 6pt minus 3pt \global\subsecheadingskip = 14pt plus 6pt minus 3pt \global\lispnarrowing = 0.3in \setleading{12pt} \advance\topskip by -1cm \global\parskip 3pt plus 1pt \global\hsize = 5in \global\vsize=7.5in \global\tolerance=700 \global\hfuzz=1pt \global\contentsrightmargin=0pt \global\deftypemargin=0pt \global\defbodyindent=.5cm \global\pagewidth=\hsize \global\pageheight=\vsize \global\let\smalllisp=\smalllispx \global\let\smallexample=\smalllispx \global\def\Esmallexample{\Esmalllisp} } % Use @afourpaper to print on European A4 paper. \def\afourpaper{ \global\tolerance=700 \global\hfuzz=1pt \setleading{12pt} \global\parskip 15pt plus 1pt \global\vsize= 53\baselineskip \advance\vsize by \topskip %\global\hsize= 5.85in % A4 wide 10pt \global\hsize= 6.5in \global\outerhsize=\hsize \global\advance\outerhsize by 0.5in \global\outervsize=\vsize \global\advance\outervsize by 0.6in \global\pagewidth=\hsize \global\pageheight=\vsize } % Allow control of the text dimensions. Parameters in order: textheight; % textwidth; \voffset; \hoffset (!); binding offset. All require a dimension; % header is additional; added length extends the bottom of the page. \def\changepagesizes#1#2#3#4#5{ \global\vsize= #1 \advance\vsize by \topskip \global\voffset= #3 \global\hsize= #2 \global\outerhsize=\hsize \global\advance\outerhsize by 0.5in \global\outervsize=\vsize \global\advance\outervsize by 0.6in \global\pagewidth=\hsize \global\pageheight=\vsize \global\normaloffset= #4 \global\bindingoffset= #5} % This layout is compatible with Latex on A4 paper. \def\afourlatex{\changepagesizes{22cm}{15cm}{7mm}{4.6mm}{5mm}} % Use @afourwide to print on European A4 paper in wide format. \def\afourwide{\afourpaper \changepagesizes{9.5in}{6.5in}{\hoffset}{\normaloffset}{\bindingoffset}} % Define macros to output various characters with catcode for normal text. \catcode`\"=\other \catcode`\~=\other \catcode`\^=\other \catcode`\_=\other \catcode`\|=\other \catcode`\<=\other \catcode`\>=\other \catcode`\+=\other \def\normaldoublequote{"} \def\normaltilde{~} \def\normalcaret{^} \def\normalunderscore{_} \def\normalverticalbar{|} \def\normalless{<} \def\normalgreater{>} \def\normalplus{+} % This macro is used to make a character print one way in ttfont % where it can probably just be output, and another way in other fonts, % where something hairier probably needs to be done. % % #1 is what to print if we are indeed using \tt; #2 is what to print % otherwise. Since all the Computer Modern typewriter fonts have zero % interword stretch (and shrink), and it is reasonable to expect all % typewriter fonts to have this, we can check that font parameter. % \def\ifusingtt#1#2{\ifdim \fontdimen3\the\font=0pt #1\else #2\fi} % Turn off all special characters except @ % (and those which the user can use as if they were ordinary). % Most of these we simply print from the \tt font, but for some, we can % use math or other variants that look better in normal text. \catcode`\"=\active \def\activedoublequote{{\tt \char '042}} \let"=\activedoublequote \catcode`\~=\active \def~{{\tt \char '176}} \chardef\hat=`\^ \catcode`\^=\active \def\auxhat{\def^{'hat}} \def^{{\tt \hat}} \catcode`\_=\active \def_{\ifusingtt\normalunderscore\_} % Subroutine for the previous macro. \def\_{\lvvmode \kern.06em \vbox{\hrule width.3em height.1ex}} % \lvvmode is equivalent in function to \leavevmode. % Using \leavevmode runs into trouble when written out to % an index file due to the expansion of \leavevmode into ``\unhbox % \voidb@x'' ---which looks to TeX like ``\unhbox \voidb\x'' due to our % magic tricks with @. \def\lvvmode{\vbox to 0pt{}} \catcode`\|=\active \def|{{\tt \char '174}} \chardef \less=`\< \catcode`\<=\active \def<{{\tt \less}} \chardef \gtr=`\> \catcode`\>=\active \def>{{\tt \gtr}} \catcode`\+=\active \def+{{\tt \char 43}} %\catcode 27=\active %\def^^[{$\diamondsuit$} % Set up an active definition for =, but don't enable it most of the time. {\catcode`\==\active \global\def={{\tt \char 61}}} \catcode`+=\active \catcode`\_=\active % If a .fmt file is being used, characters that might appear in a file % name cannot be active until we have parsed the command line. % So turn them off again, and have \everyjob (or @setfilename) turn them on. % \otherifyactive is called near the end of this file. \def\otherifyactive{\catcode`+=\other \catcode`\_=\other} \catcode`\@=0 % \rawbackslashxx output one backslash character in current font \global\chardef\rawbackslashxx=`\\ %{\catcode`\\=\other %@gdef@rawbackslashxx{\}} % \rawbackslash redefines \ as input to do \rawbackslashxx. {\catcode`\\=\active @gdef@rawbackslash{@let\=@rawbackslashxx }} % \normalbackslash outputs one backslash in fixed width font. \def\normalbackslash{{\tt\rawbackslashxx}} % Say @foo, not \foo, in error messages. \escapechar=`\@ % \catcode 17=0 % Define control-q \catcode`\\=\active % Used sometimes to turn off (effectively) the active characters % even after parsing them. @def@turnoffactive{@let"=@normaldoublequote @let\=@realbackslash @let~=@normaltilde @let^=@normalcaret @let_=@normalunderscore @let|=@normalverticalbar @let<=@normalless @let>=@normalgreater @let+=@normalplus} @def@normalturnoffactive{@let"=@normaldoublequote @let\=@normalbackslash @let~=@normaltilde @let^=@normalcaret @let_=@normalunderscore @let|=@normalverticalbar @let<=@normalless @let>=@normalgreater @let+=@normalplus} % Make _ and + \other characters, temporarily. % This is canceled by @fixbackslash. @otherifyactive % If a .fmt file is being used, we don't want the `\input texinfo' to show up. % That is what \eatinput is for; after that, the `\' should revert to printing % a backslash. % @gdef@eatinput input texinfo{@fixbackslash} @global@let\ = @eatinput % On the other hand, perhaps the file did not have a `\input texinfo'. Then % the first `\{ in the file would cause an error. This macro tries to fix % that, assuming it is called before the first `\' could plausibly occur. % Also back turn on active characters that might appear in the input % file name, in case not using a pre-dumped format. % @gdef@fixbackslash{@ifx\@eatinput @let\ = @normalbackslash @fi @catcode`+=@active @catcode`@_=@active} %% These look ok in all fonts, so just make them not special. The @rm below %% makes sure that the current font starts out as the newly loaded cmr10 @catcode`@$=@other @catcode`@%=@other @catcode`@&=@other @catcode`@#=@other @textfonts @rm @c Local variables: @c page-delimiter: "^\\\\message" @c End: textutils-1.12/doc/textutils.texi100644 74504 13 277732 5770204022 16345 0ustar meyeringuser\input texinfo @c %**start of header @setfilename textutils.info @settitle GNU text utilities @c %**end of header @include version.texi @c Define new indices. @defcodeindex op @c Put everything in one index (arbitrarily chosen to be the concept index). @syncodeindex fn cp @syncodeindex ky cp @syncodeindex op cp @syncodeindex pg cp @syncodeindex vr cp @ifinfo @set Francois Franc,ois @end ifinfo @tex @set Francois Fran\noexpand\ptexc cois @end tex @ifinfo @format START-INFO-DIR-ENTRY * Text utilities: (textutils). GNU text utilities. * cat: (textutils)cat invocation. Concatenate and write files. * cksum: (textutils)cksum invocation. Print POSIX CRC checksum. * comm: (textutils)comm invocation. Compare sorted files by line. * csplit: (textutils)csplit invocation. Split by context. * cut: (textutils)cut invocation. Print selected parts of lines. * expand: (textutils)expand invocation. Convert tabs to spaces. * fmt: (textutils)fmt invocation. Reformat paragraph text. * fold: (textutils)fold invocation. Wrap long input lines. * head: (textutils)head invocation. Output the first part of files. * join: (textutils)join invocation. Join lines on a common field. * md5sum: (textutils)md5sum invocation. Print or check message-digests. * nl: (textutils)nl invocation. Number lines and write files. * od: (textutils)od invocation. Dump files in octal, etc. * paste: (textutils)paste invocation. Merge lines of files. * pr: (textutils)pr invocation. Paginate or columnate files. * sort: (textutils)sort invocation. Sort text files. * split: (textutils)split invocation. Split into fixed-size pieces. * sum: (textutils)sum invocation. Print traditional checksum. * tac: (textutils)tac invocation. Reverse files. * tail: (textutils)tail invocation. Output the last part of files. * tr: (textutils)tr invocation. Translate characters. * unexpand: (textutils)unexpand invocation. Convert spaces to tabs. * uniq: (textutils)uniq invocation. Uniqify files. * wc: (textutils)wc invocation. Byte, word, and line counts. END-INFO-DIR-ENTRY @end format @end ifinfo @ifinfo This file documents the GNU text utilities. Copyright (C) 1994, 95 Free Software Foundation, Inc. Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. @ignore Permission is granted to process this file through TeX and print the results, provided the printed document carries copying permission notice identical to this one except for the removal of this paragraph (this paragraph not being relevant to the printed manual). @end ignore Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that this permission notice may be stated in a translation approved by the Foundation. @end ifinfo @titlepage @title GNU @code{textutils} @subtitle A set of text utilities @subtitle for version @value{VERSION}, @value{RELEASEDATE} @author David MacKenzie et al. @page @vskip 0pt plus 1filll Copyright @copyright{} 1994, 95 Free Software Foundation, Inc. Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that this permission notice may be stated in a translation approved by the Foundation. @end titlepage @ifinfo @node Top @top GNU text utilities @cindex text utilities @cindex utilities for text handling This manual minimally documents version @value{VERSION} of the GNU text utilities. @menu * Introduction:: Caveats, overview, and authors. * Common options:: Common options. * Output of entire files:: cat tac nl od * Formatting file contents:: fmt pr fold * Output of parts of files:: head tail split csplit * Summarizing files:: wc sum cksum md5sum * Operating on sorted files:: sort uniq comm * Operating on fields within a line:: cut paste join * Operating on characters:: tr expand unexpand * Opening the software toolbox:: The software tools philosophy. * Index:: General index. @end menu @end ifinfo @node Introduction @chapter Introduction @cindex introduction This manual is incomplete: No attempt is made to explain basic concepts in a way suitable for novices. Thus, if you are interested, please get involved in improving this manual. The entire GNU community will benefit. @cindex POSIX.2 The GNU text utilities are mostly compatible with the POSIX.2 standard. @c This paragraph appears in all of fileutils.texi, textutils.texi, and @c sh-utils.texi too -- so be sure to keep them consistent. @cindex bugs, reporting Please report bugs to @samp{bug-gnu-utils@@prep.ai.mit.edu}. Remember to include the version number, machine architecture, input files, and any other information needed to reproduce the bug: your input, what you expected, what you got, and why it is wrong. Diffs are welcome, but please include a description of the problem as well, since this is sometimes difficult to infer. @xref{Bugs, , , gcc, GNU CC}. This manual is based on the Unix man pages in the distribution, which were originally written by David MacKenzie and updated by Jim Meyering. The original @code{fmt} man page was written by Ross Paterson. @value{Francois} Pinard did the initial conversion to Texinfo format. Karl Berry did the indexing, some reorganization, and editing of the results. Richard Stallman contributed his usual invaluable insights to the overall process. @node Common options @chapter Common options @cindex common options Certain options are available in all these programs. Rather than writing identical descriptions for each of the programs, they are described here. (In fact, every GNU program accepts (or should accept) these options.) A few of these programs take arbitrary strings as arguments. In those cases, @samp{--help} and @samp{--version} are taken as these options only if there is one and exactly one command line argument. @table @samp @item --help @opindex --help @cindex help, online Print a usage message listing all available options, then exit successfully. @item --version @opindex --version @cindex version number, finding Print the version number, then exit successfully. @end table @node Output of entire files @chapter Output of entire files @cindex output of entire files @cindex entire files, output of These commands read and write entire files, possibly transforming them in some way. @menu * cat invocation:: Concatenate and write files. * tac invocation:: Concatenate and write files in reverse. * nl invocation:: Number lines and write files. * od invocation:: Write files in octal or other formats. @end menu @node cat invocation @section @code{cat}: Concatenate and write files @pindex cat @cindex concatenate and write files @cindex copying files @code{cat} copies each @var{file} (@samp{-} means standard input), or standard input if none are given, to standard output. Synopsis: @example cat [@var{option}] [@var{file}]@dots{} @end example The program accepts the following options. Also see @ref{Common options}. @table @samp @item -A @itemx --show-all @opindex -A @opindex --show-all Equivalent to @samp{-vET}. @item -b @itemx --number-nonblank @opindex -b @opindex --number-nonblank Number all nonblank output lines, starting with 1. @item -e @opindex -e Equivalent to @samp{-vE}. @item -E @itemx --show-ends @opindex -E @opindex --show-ends Display a @samp{$} after the end of each line. @item -n @itemx --number @opindex -n @opindex --number Number all output lines, starting with 1. @item -s @itemx --squeeze-blank @opindex -s @opindex --squeeze-blank @cindex squeezing blank lines Replace multiple adjacent blank lines with a single blank line. @item -t @opindex -t Equivalent to @samp{-vT}. @item -T @itemx --show-tabs @opindex -T @opindex --show-tabs Display @key{TAB} characters as @samp{^I}. @item -u @opindex -u Ignored; for Unix compatibility. @item -v @itemx --show-nonprinting @opindex -v @opindex --show-nonprinting Display control characters except for @key{LFD} and @key{TAB} using @samp{^} notation and precede characters that have the high bit set with @samp{M-}. @end table @node tac invocation @section @code{tac}: Concatenate and write files in reverse @pindex tac @cindex reversing files @code{tac} copies each @var{file} (@samp{-} means standard input), or standard input if none are given, to standard output, reversing the records (lines by default) in each separately. Synopsis: @example tac [@var{option}]@dots{} [@var{file}]@dots{} @end example @dfn{Records} are separated by instances of a string (newline by default). By default, this separator string is attached to the end of the record that it follows in the file. The program accepts the following options. Also see @ref{Common options}. @table @samp @item -b @itemx --before @opindex -b @opindex --before The separator is attached to the beginning of the record that it precedes in the file. @item -r @itemx --regex @opindex -r @opindex --regex Treat the separator string as a regular expression. @item -s @var{separator} @itemx --separator=@var{separator} @opindex -s @opindex --separator Use @var{separator} as the record separator, instead of newline. @end table @node nl invocation @section @code{nl}: Number lines and write files @pindex nl @cindex numbering lines @cindex line numbering @code{nl} writes each @var{file} (@samp{-} means standard input), or standard input if none are given, to standard output, with line numbers added to some or all of the lines. Synopsis: @example nl [@var{option}]@dots{} [@var{file}]@dots{} @end example @cindex logical pages, numbering on @code{nl} decomposes its input into (logical) pages; by default, the line number is reset to 1 at the top of each logical page. @code{nl} treats all of the input files as a single document; it does not reset line numbers or logical pages between files. @cindex headers, numbering @cindex body, numbering @cindex footers, numbering A logical page consists of three sections: header, body, and footer. Any of the sections can be empty. Each can be numbered in a different style from the others. The beginnings of the sections of logical pages are indicated in the input file by a line containing exactly one of these delimiter strings: @table @samp @item \:\:\: start of header; @item \:\: start of body; @item \: start of footer. @end table The two characters from which these strings are made can be changed from @samp{\} and @samp{:} via options (see below), but the pattern and length of each string cannot be changed. A section delimiter is replaced by an empty line on output. Any text that comes before the first section delimiter string in the input file is considered to be part of a body section, so @code{nl} treats a file that contains no section delimiters as a single body section. The program accepts the following options. Also see @ref{Common options}. @table @samp @item -b @var{style} @itemx --body-numbering=@var{style} @opindex -b @opindex --body-numbering Select the numbering style for lines in the body section of each logical page. When a line is not numbered, the current line number is not incremented, but the line number separator character is still prepended to the line. The styles are: @table @samp @item a number all lines, @item t number only nonempty lines (default for body), @item n do not number lines (default for header and footer), @item p@var{regexp} number only lines that contain a match for @var{regexp}. @end table @item -d @var{cd} @itemx --section-delimiter=@var{cd} @opindex -d @opindex --section-delimiter @cindex section delimiters of pages Set the section delimiter characters to @var{cd}; default is @samp{\:}. If only @var{c} is given, the second remains @samp{:}. (Remember to protect @samp{\} or other metacharacters from shell expansion with quotes or extra backslashes.) @item -f @var{style} @itemx --footer-numbering=@var{style} @opindex -f @opindex --footer-numbering Analogous to @samp{--body-numbering}. @item -h @var{style} @itemx --header-numbering=@var{style} @opindex -h @opindex --header-numbering Analogous to @samp{--body-numbering}. @item -i @var{number} @itemx --page-increment=@var{number} @opindex -i @opindex --page-increment Increment line numbers by @var{number} (default 1). @item -l @var{number} @itemx --join-blank-lines=@var{number} @opindex -l @opindex --join-blank-lines @cindex empty lines, numbering @cindex blank lines, numbering Consider @var{number} (default 1) consecutive empty lines to be one logical line for numbering, and only number the last one. Where fewer than @var{number} consecutive empty lines occur, do not number them. An empty line is one that contains no characters, not even spaces or tabs. @item -n @var{format} @itemx --number-format=@var{format} @opindex -n @opindex --number-format Select the line numbering format (default is @code{rn}): @table @samp @item ln @opindex ln @r{format for @code{nl}} left justified, no leading zeros; @item rn @opindex rn @r{format for @code{nl}} right justified, no leading zeros; @item rz @opindex rz @r{format for @code{nl}} right justified, leading zeros. @end table @item -p @itemx --no-renumber @opindex -p @opindex --no-renumber Do not reset the line number at the start of a logical page. @item -s @var{string} @itemx --number-separator=@var{string} @opindex -s @opindex --number-separator Separate the line number from the text line in the output with @var{string} (default is @key{TAB}). @item -v @var{number} @itemx --first-page=@var{number} @opindex -v @opindex --first-page Set the initial line number on each logical page to @var{number} (default 1). @item -w @var{number} @itemx --number-width=@var{number} @opindex -w @opindex --number-width Use @var{number} characters for line numbers (default 6). @end table @node od invocation @section @code{od}: Write files in octal or other formats @pindex od @cindex octal dump of files @cindex hex dump of files @cindex ASCII dump of files @cindex file contents, dumping unambiguously @code{od} writes an unambiguous representation of each @var{file} (@samp{-} means standard input), or standard input if none are given. Synopsis: @example od [@var{option}]@dots{} [@var{file}]@dots{} od -C [@var{file}] [[+]@var{offset} [[+]@var{label}]] @end example Each line of output consists of the offset in the input, followed by groups of data from the file. By default, @code{od} prints the offset in octal, and each group of file data is two bytes of input printed as a single octal number. The program accepts the following options. Also see @ref{Common options}. @table @samp @item -A @var{radix} @itemx --address-radix=@var{radix} @opindex -A @opindex --address-radix @cindex radix for file offsets @cindex file offset radix Select the base in which file offsets are printed. @var{radix} can be one of the following: @table @samp @item d decimal; @item o octal; @item x hexadecimal; @item n none (do not print offsets). @end table The default is octal. @item -j @var{bytes} @itemx --skip-bytes=@var{bytes} @opindex -j @opindex --skip-bytes Skip @var{bytes} input bytes before formatting and writing. If @var{bytes} begins with @samp{0x} or @samp{0X}, it is interpreted in hexadecimal; otherwise, if it begins with @samp{0}, in octal; otherwise, in decimal. Appending @samp{b} multiplies @var{bytes} by 512, @samp{k} by 1024, and @samp{m} by 1048576. @item -N @var{bytes} @itemx --read-bytes=@var{bytes} @opindex -N @opindex --read-bytes Output at most @var{bytes} bytes of the input. Prefixes and suffixes on @code{bytes} are interpreted as for the @samp{-j} option. @item -s [@var{n}] @itemx --strings[=@var{n}] @opindex -s @opindex --strings @cindex string constants, outputting Instead of the normal output, output only @dfn{string constants}: at least @var{n} (3 by default) consecutive ASCII graphic characters, followed by a null (zero) byte. @item -t @var{type} @itemx --format=@var{type} @opindex -t @opindex --format Select the format in which to output the file data. @var{type} is a string of one or more of the below type indicator characters. If you include more than one type indicator character in a single @var{type} string, or use this option more than once, @code{od} writes one copy of each output line using each of the data types that you specified, in the order that you specified. @table @samp @item a named character, @item c ASCII character or backslash escape, @item d signed decimal, @item f floating point, @item o octal, @item u unsigned decimal, @item x hexadecimal. @end table The type @code{a} outputs things like @samp{sp} for space, @samp{nl} for newline, and @samp{nul} for a null (zero) byte. Type @code{c} outputs @samp{ }, @samp{\n}, and @code{\0}, respectively. @cindex type size Except for types @samp{a} and @samp{c}, you can specify the number of bytes to use in interpreting each number in the given data type by following the type indicator character with a decimal integer. Alternately, you can specify the size of one of the C compiler's built-in data types by following the type indicator character with one of the following characters. For integers (@samp{d}, @samp{o}, @samp{u}, @samp{x}): @table @samp @item C char, @item S short, @item I int, @item L long. @end table For floating point (@code{f}): @table @asis @item F float, @item D double, @item L long double. @end table @item -v @itemx --output-duplicates @opindex -v @opindex --output-duplicates Output consecutive lines that are identical. By default, when two or more consecutive output lines would be identical, @code{od} outputs only the first line, and puts just an asterisk on the following line to indicate the elision. @item -w [@var{n}] @itemx --width[=@var{n}] @opindex -w @opindex --width Dump @code{n} input bytes per output line. This must be a multiple of the least common multiple of the sizes associated with the specified output types. If @var{n} is omitted, the default is 32. If this option is not given at all, the default is 16. @end table The next several options map the old, pre-POSIX format specification options to the corresponding POSIX format specs. GNU @code{od} accepts any combination of old- and new-style options. Format specification options accumulate. @table @samp @item -a @opindex -a Output as named characters. Equivalent to @samp{-ta}. @item -b @opindex -b Output as octal bytes. Equivalent to @samp{-toC}. @item -c @opindex -c Output as ASCII characters or backslash escapes. Equivalent to @samp{-tc}. @item -d @opindex -d Output as unsigned decimal shorts. Equivalent to @samp{-tu2}. @item -f @opindex -f Output as floats. Equivalent to @samp{-tfF}. @item -h @opindex -h Output as hexadecimal shorts. Equivalent to @samp{-tx2}. @item -i @opindex -i Output as decimal shorts. Equivalent to @samp{-td2}. @item -l @opindex -l Output as decimal longs. Equivalent to @samp{-td4}. @item -o @opindex -o Output as octal shorts. Equivalent to @samp{-to2}. @item -x @opindex -x Output as hexadecimal shorts. Equivalent to @samp{-tx2}. @item -C @itemx --traditional @opindex --traditional Recognize the pre-POSIX non-option arguments that traditional @code{od} accepted. The following syntax: @example od --traditional [@var{file}] [[+]@var{offset}[.][b] [[+]@var{label}[.][b]]] @end example @noindent can be used to specify at most one file and optional arguments specifying an offset and a pseudo-start address, @var{label}. By default, @var{offset} is interpreted as an octal number specifying how many input bytes to skip before formatting and writing. The optional trailing decimal point forces the interpretation of @var{offset} as a decimal number. If no decimal is specified and the offset begins with @samp{0x} or @samp{0X} it is interpreted as a hexadecimal number. If there is a trailing @samp{b}, the number of bytes skipped will be @var{offset} multiplied by 512. The @var{label} argument is interpreted just like @var{offset}, but it specifies an initial pseudo-address. The pseudo-addresses are displayed in parentheses following any normal address. @end table @node Formatting file contents @chapter Formatting file contents @cindex formatting file contents These commands reformat the contents of files. @menu * fmt invocation:: Reformat paragraph text. * pr invocation:: Paginate or columnate files for printing. * fold invocation:: Wrap input lines to fit in specified width. @end menu @node fmt invocation @section @code{fmt}: Reformat paragraph text @pindex fmt @cindex reformatting paragraph text @cindex paragraphs, reformatting @cindex text, reformatting @code{fmt} fills and joins lines to produce output lines of (at most) a given number of characters (75 by default). Synopsis: @example fmt [@var{option}]@dots{} [@var{file}]@dots{} @end example @code{fmt} reads from the specified @var{file} arguments (or standard input if none are given), and writes to standard output. By default, blank lines, spaces between words, and indentation are preserved in the output; successive input lines with different indentation are not joined; tabs are expanded on input and introduced on output. @cindex line-breaking @cindex sentences and line-breaking @cindex Knuth, Donald E. @cindex Plass, Michael F. @code{fmt} prefers breaking lines at the end of a sentence, and tries to avoid line breaks after the first word of a sentence or before the last word of a sentence. A @dfn{sentence break} is defined as either the end of a paragraph or a word ending in any of @samp{.?!}, followed by two spaces or end of line, ignoring any intervening parentheses or quotes. Like @TeX{}, @code{fmt} reads entire ``paragraphs'' before choosing line breaks; the algorithm is a variant of that in ``Breaking Paragraphs Into Lines'' (Donald E. Knuth and Michael F. Plass, @cite{Software---Practice and Experience}, 11 (1981), 1119--1184). The program accepts the following options. Also see @ref{Common options}. @table @samp @item -c @itemx --crown-margin @opindex -c @opindex --crown-margin @cindex crown margin @dfn{Crown margin} mode: preserve the indentation of the first two lines within a paragraph, and align the left margin of each subsequent line with that of the second line. @item -t @itemx --tagged-paragraph @opindex -t @opindex --tagged-paragraph @cindex tagged paragraphs @dfn{Tagged paragraph} mode: like crown margin mode, except that if indentation of the first line of a paragraph is the same as the indentation of the second, the first line is treated as a one-line paragraph. @item -s @itemx --split-only @opindex -s @opindex --split-only Split lines only. Do not join short lines to form longer ones. This prevents sample lines of code, and other such ``formatted'' text from being unduly combined. @item -u @itemx --uniform-spacing @opindex -u @opindex --uniform-spacing Uniform spacing. Reduce spacing between words to one space, and spacing between sentences to two spaces. @item -@var{width} @itemx -w @var{width} @itemx --width=@var{width} @opindex -@var{width} @opindex -w @opindex --width Fill output lines up to @var{width} characters (default 75). @code{fmt} initially tries to make lines about 7% shorter than this, to give it room to balance line lengths. @item -p @var{prefix} @itemx --prefix=@var{prefix} Only lines beginning with @var{prefix} (possibly preceded by whitespace) are subject to formatting. The prefix and any preceding whitespace is stripped for the formatting and then re-attached to each formatted output line. One use is to format certain kinds of program comments, while leaving the code unchanged. @end table @node pr invocation @section @code{pr}: Paginate or columnate files for printing @pindex pr @cindex printing, preparing files for @cindex multicolumn output, generating @code{pr} writes each @var{file} (@samp{-} means standard input), or standard input if none are given, to standard output, paginating and optionally outputting in multicolumn format. Synopsis: @example pr [@var{option}]@dots{} [@var{file}]@dots{} @end example By default, a 5-line header is printed: two blank lines; a line with the date, the file name, and the page count; and two more blank lines. A five line footer (entirely) is also printed. Form feeds in the input cause page breaks in the output. The program accepts the following options. Also see @ref{Common options}. @table @samp @item +@var{page} Begin printing with page @var{page}. @item -@var{column} @opindex -@var{column} Produce @var{column}-column output and print columns down. The column width is automatically decreased as @var{column} increases; unless you use the @samp{-w} option to increase the page width as well, this option might well cause some input to be truncated. @item -a @opindex -a @cindex across columns Print columns across rather than down. @item -b @opindex -b @cindex balancing columns Balance columns on the last page. @item -c @opindex -c Print control characters using hat notation (e.g., @samp{^G}); print other unprintable characters in octal backslash notation. By default, unprintable characters are not changed. @item -d @opindex -d @cindex double spacing Double space the output. @item -e[@var{in-tabchar}[@var{in-tabwidth}]] @opindex -e @cindex input tabs Expand tabs to spaces on input. Optional argument @var{in-tabchar} is the input tab character (default is @key{TAB}). Second optional argument @var{in-tabwidth} is the input tab character's width (default is 8). @item -f @itemx -F @opindex -F @opindex -f Use a formfeed instead of newlines to separate output pages. @item -h @var{header} @opindex -h Replace the file name in the header with the string @var{header}. @item -i[@var{out-tabchar}[@var{out-tabwidth}]] @opindex -i @cindex output tabs Replace spaces with tabs on output. Optional argument @var{out-tabchar} is the output tab character (default is @key{TAB}). Second optional argument @var{out-tabwidth} is the output tab character's width (default is 8). @item -l @var{n} @opindex -l Set the page length to @var{n} (default 66) lines. If @var{n} is less than 10, the headers and footers are omitted, as if the @samp{-t} option had been given. @item -m @opindex -m Print all files in parallel, one in each column. @item -n[@var{number-separator}[@var{digits}]] @opindex -n Precede each column with a line number; with parallel files (@samp{-m}), precede each line with a line number. Optional argument @var{number-separator} is the character to print after each number (default is @key{TAB}). Optional argument @var{digits} is the number of digits per line number (default is 5). @item -o @var{n} @opindex -o @cindex indenting lines @cindex left margin Indent each line with @var{n} (default is zero) spaces wide, i.e., set the left margin. The total page width is @samp{n} plus the width set with the @samp{-w} option. @item -r @opindex -r Do not print a warning message when an argument @var{file} cannot be opened. (The exit status will still be nonzero, however.) @item -s[@var{c}] @opindex -s Separate columns by the single character @var{c}. If @var{c} is omitted, the default is space; if this option is omitted altogether, the default is @key{TAB}. @item -t @opindex -t Do not print the usual 5-line header and the 5-line footer on each page, and do not fill out the bottoms of pages (with blank lines or formfeeds). @item -v @opindex -v Print unprintable characters in octal backslash notation. @item -w @var{n} @opindex -w Set the page width to @var{n} (default is 72) columns. @end table @node fold invocation @section @code{fold}: Wrap input lines to fit in specified width @pindex fold @cindex wrapping long input lines @cindex folding long input lines @code{fold} writes each @var{file} (@samp{-} means standard input), or standard input if none are given, to standard output, breaking long lines. Synopsis: @example fold [@var{option}]@dots{} [@var{file}]@dots{} @end example By default, @code{fold} breaks lines wider than 80 columns. The output is split into as many lines as necessary. @cindex screen columns @code{fold} counts screen columns by default; thus, a tab may count more than one column, backspace decreases the column count, and carriage return sets the column to zero. The program accepts the following options. Also see @ref{Common options}. @table @samp @item -b @itemx --bytes @opindex -b @opindex --bytes Count bytes rather than columns, so that tabs, backspaces, and carriage returns are each counted as taking up one column, just like other characters. @item -s @itemx --spaces @opindex -s @opindex --spaces Break at word boundaries: the line is broken after the last blank before the maximum line length. If the line contains no such blanks, the line is broken at the maximum line length as usual. @item -w @var{width} @itemx --width=@var{width} @opindex -w @opindex --width Use a maximum line length of @var{width} columns instead of 80. @end table @node Output of parts of files @chapter Output of parts of files @cindex output of parts of files @cindex parts of files, output of These commands output pieces of the input. @menu * head invocation:: Output the first part of files. * tail invocation:: Output the last part of files. * split invocation:: Split a file into fixed-size pieces. * csplit invocation:: Split a file into context-determined pieces. @end menu @node head invocation @section @code{head}: Output the first part of files @pindex head @cindex initial part of files, outputting @cindex first part of files, outputting @code{head} prints the first part (10 lines by default) of each @var{file}; it reads from standard input if no files are given or when given a @var{file} of @samp{-}. Synopses: @example head [@var{option}]@dots{} [@var{file}]@dots{} head -@var{number} [@var{option}]@dots{} [@var{file}]@dots{} @end example If more than one @var{file} is specicified, @code{head} prints a one-line header consisting of @example ==> @var{file name} <== @end example @noindent before the output for each @var{file}. @code{head} accepts two option formats: the new one, in which numbers are arguments to the options (@samp{-q -n 1}), and the old one, in which the number precedes any option letters (@samp{-1q}). The program accepts the following options. Also see @ref{Common options}. @table @samp @item -@var{count}@var{options} @opindex -@var{count} This option is only recognized if it is specified first. @var{count} is a decimal number optionally followed by a size letter (@samp{b}, @samp{k}, @samp{m}) as in @code{-c}, or @samp{l} to mean count by lines, or other option letters (@samp{cqv}). @item -c @var{bytes} @itemx --bytes=@var{bytes} @opindex -c @opindex --bytes Print the first @var{bytes} bytes, instead of initial lines. Appending @samp{b} multiplies @var{bytes} by 512, @samp{k} by 1024, and @samp{m} by 1048576. @itemx -n @var{n} @itemx --lines=@var{n} @opindex -n @opindex --lines Output the first @var{n} lines. @item -q @itemx --quiet @itemx --silent @opindex -q @opindex --quiet @opindex --silent Never print file name headers. @item -v @itemx --verbose @opindex -v @opindex --verbose Always print file name headers. @end table @node tail invocation @section @code{tail}: Output the last part of files @pindex tail @cindex last part of files, outputting @code{tail} prints the last part (10 lines by default) of each @var{file}; it reads from standard input if no files are given or when given a @var{file} of @samp{-}. Synopses: @example tail [@var{option}]@dots{} [@var{file}]@dots{} tail -@var{number} [@var{option}]@dots{} [@var{file}]@dots{} tail +@var{number} [@var{option}]@dots{} [@var{file}]@dots{} @end example If more than one @var{file} is specified, @code{tail} prints a one-line header consisting of @example ==> @var{file name} <== @end example @noindent before the output for each @var{file}. @cindex BSD @code{tail} GNU @code{tail} can output any amount of data (some other versions of @code{tail} cannot). It also has no @samp{-r} option (print in reverse), since reversing a file is really a different job from printing the end of a file; BSD @code{tail} (which is the one with @code{-r}) can only reverse files that are at most as large as its buffer, which is typically 32k. A more reliable and versatile way to reverse files is the GNU @code{tac} command. @code{tail} accepts two option formats: the new one, in which numbers are arguments to the options (@samp{-n 1}), and the old one, in which the number precedes any option letters (@samp{-1} or @samp{+1}). If any option-argument is a number @var{n} starting with a @samp{+}, @code{tail} begins printing with the @var{n}th item from the start of each file, instead of from the end. The program accepts the following options. Also see @ref{Common options}. @table @samp @item -@var{count} @itemx +@var{count} @opindex -@var{count} @opindex +@var{count} This option is only recognized if it is specified first. @var{count} is a decimal number optionally followed by a size letter (@samp{b}, @samp{k}, @samp{m}) as in @code{-c}, or @samp{l} to mean count by lines, or other option letters (@samp{cfqv}). @item -c @var{bytes} @itemx --bytes=@var{bytes} @opindex -c @opindex --bytes Output the last @var{bytes} bytes, instead of final lines. Appending @samp{b} multiplies @var{bytes} by 512, @samp{k} by 1024, and @samp{m} by 1048576. @item -f @itemx --follow @opindex -f @opindex --follow @cindex growing files Loop forever trying to read more characters at the end of the file, presumably because the file is growing. Ignored if reading from a pipe. If more than one file is given, @code{tail} prints a header whenever it gets output from a different file, to indicate which file that output is from. @itemx -n @var{n} @itemx --lines=@var{n} @opindex -n @opindex --lines Output the last @var{n} lines. @item -q @itemx -quiet @itemx --silent @opindex -q @opindex --quiet @opindex --silent Never print file name headers. @item -v @itemx --verbose @opindex -v @opindex --verbose Always print file name headers. @end table @node split invocation @section @code{split}: Split a file into fixed-size pieces @pindex split @cindex splitting a file into pieces @cindex pieces, splitting a file into @code{split} creates output files containing consecutive sections of @var{input} (standard input if none is given or @var{input} is @samp{-}). Synopsis: @example split [@var{option}] [@var{input} [@var{prefix}]] @end example By default, @code{split} puts 1000 lines of @var{input} (or whatever is left over for the last section), into each output file. @cindex output file name prefix The output files' names consist of @var{prefix} (@samp{x} by default) followed by a group of letters @samp{aa}, @samp{ab}, and so on, such that concatenating the output files in sorted order by file name produces the original input file. (If more than 676 output files are required, @code{split} uses @samp{zaa}, @samp{zab}, etc.) The program accepts the following options. Also see @ref{Common options}. @table @samp @item -@var{lines} @itemx -l @var{lines} @itemx --lines=@var{lines} @opindex -l @opindex --lines Put @var{lines} lines of @var{input} into each output file. @item -b @var{bytes} @itemx --bytes=@var{bytes} @opindex -b @opindex --bytes Put the first @var{bytes} bytes of @var{input} into each output file. Appending @samp{b} multiplies @var{bytes} by 512, @samp{k} by 1024, and @samp{m} by 1048576. @item -C @var{bytes} @itemx --line-bytes=@var{bytes} @opindex -C @opindex --line-bytes Put into each output file as many complete lines of @var{input} as possible without exceeding @var{bytes} bytes. For lines longer than @var{bytes} bytes, put @var{bytes} bytes into each output file until less than @var{bytes} bytes of the line are left, then continue normally. @var{bytes} has the same format as for the @samp{--bytes} option. @end table @node csplit invocation @section @code{csplit}: Split a file into context-determined pieces @pindex csplit @cindex context splitting @cindex splitting a file into pieces by context @code{csplit} creates zero or more output files containing sections of @var{input} (standard input if @var{input} is @samp{-}). Synopsis: @example csplit [@var{option}]@dots{} @var{input} @var{pattern}@dots{} @end example The contents of the output files are determined by the @var{pattern} arguments, as detailed below. An error occurs if a @var{pattern} argument refers to a nonexistent line of the input file (e.g., if no remaining line matches a given regular expression). After every @var{pattern} has been matched, any remaining input is copied into one last output file. By default, @code{csplit} prints the number of bytes written to each output file after it has been created. The types of pattern arguments are: @table @samp @item @var{n} Create an output file containing the input up to but not including line @var{n} (a positive integer). If followed by a repeat count, also create an output file containing the next @var{line} lines of the input file once for each repeat. @item /@var{regexp}/[@var{offset}] Create an output file containing the current line up to (but not including) the next line of the input file that contains a match for @var{regexp}. The optional @var{offset} is a @samp{+} or @samp{-} followed by a positive integer. If it is given, the input up to the matching line plus or minus @var{offset} is put into the output file, and the line after that begins the next section of input. @item %@var{regexp}%[@var{offset}] Like the previous type, except that it does not create an output file, so that section of the input file is effectively ignored. @item @{@var{repeat-count}@} Repeat the previous pattern @var{repeat-count} additional times. @var{repeat-count} can either be a positive integer or an asterisk, meaning repeat as many times as necessary until the input is exausted. @end table The output files' names consist of a prefix (@samp{xx} by default) followed by a suffix. By default, the suffix is an ascending sequence of two-digit decimal numbers from @samp{00} and up to @samp{99}. In any case, concatenating the output files in sorted order by filename produces the original input file. By default, if @code{csplit} encounters an error or receives a hangup, interrupt, quit, or terminate signal, it removes any output files that it has created so far before it exits. The program accepts the following options. Also see @ref{Common options}. @table @samp @item -f @var{prefix} @itemx --prefix=@var{prefix} @opindex -f @opindex --prefix @cindex output file name prefix Use @var{prefix} as the output file name prefix. @item -b @var{suffix} @itemx --suffix=@var{suffix} @opindex -b @opindex --suffix @cindex output file name suffix Use @var{suffix} as the output file name suffix. When this option is specified, the suffix string must include exactly one @code{printf(3)}-style conversion specification, possibly including format specification flags, a field width, a precision specifications, or all of these kinds of modifiers. The format letter must convert a binary integer argument to readable form; thus, only @samp{d}, @samp{i}, @samp{u}, @samp{o}, @samp{x}, and @samp{X} conversions are allowed. The entire @var{suffix} is given (with the current output file number) to @code{sprintf(3)} to form the file name suffixes for each of the individual output files in turn. If this option is used, the @samp{--digits} option is ignored. @item -n @var{digits} @itemx --digits=@var{digits} @opindex -n @opindex --digits Use output file names containing numbers that are @var{digits} digits long instead of the default 2. @item -k @itemx --keep-files @opindex -k @opindex --keep-files Do not remove output files when errors are encountered. @item -z @itemx --elide-empty-files @opindex -z @opindex --elide-empty-files Suppress the generation of zero-length output files. (In cases where the section delimiters of the input file are supposed to mark the first lines of each of the sections, the first output file will generally be a zero-length file unless you use this option.) The output file sequence numbers always run consecutively starting from 0, even when this option is specified. @item -s @itemx -q @itemx --silent @itemx --quiet @opindex -s @opindex -q @opindex --silent @opindex --quiet Do not print counts of output file sizes. @end table @node Summarizing files @chapter Summarizing files @cindex summarizing files These commands generate just a few numbers representing entire contents of files. @menu * wc invocation:: Print byte, word, and line counts. * sum invocation:: Print checksum and block counts. * cksum invocation:: Print CRC checksum and byte counts. * md5sum invocation:: Print or check message-digests. @end menu @node wc invocation @section @code{wc}: Print byte, word, and line counts @pindex wc @cindex byte count @cindex word count @cindex line count @code{wc} counts the number of bytes, whitespace-separated words, and newlines in each given @var{file}, or standard input if none are given or for a @var{file} of @samp{-}. Synopsis: @example wc [@var{option}]@dots{} [@var{file}]@dots{} @end example @cindex total counts @code{wc} prints one line of counts for each file, and if the file was given as an argument, it prints the file name following the counts. If more than one @var{file} is given, @code{wc} prints a final line containing the cumulative counts, with the file name @file{total}. The counts are printed in this order: newlines, words, bytes. By default, @code{wc} prints all three counts. Options can specify that only certain counts be printed. Options do not undo others previously given, so @example wc --bytes --words @end example @noindent prints both the byte counts and the word counts. The program accepts the following options. Also see @ref{Common options}. @table @samp @item -c @itemx --bytes @itemx --chars @opindex -c @opindex --bytes @opindex --chars Print only the byte counts. @item -w @itemx --words @opindex -w @opindex --words Print only the word counts. @item -l @itemx --lines @opindex -l @opindex --lines Print only the newline counts. @end table @node sum invocation @section @code{sum}: Print checksum and block counts @pindex sum @cindex 16-bit checksum @cindex checksum, 16-bit @code{sum} computes a 16-bit checksum for each given @var{file}, or standard input if none are given or for a @var{file} of @samp{-}. Synopsis: @example sum [@var{option}]@dots{} [@var{file}]@dots{} @end example @code{sum} prints the checksum for each @var{file} followed by the number of blocks in the file (rounded up). If more than one @var{file} is given, file names are also printed (by default). (With the @samp{--sysv} option, corresponding file name are printed when there is at least one file argument.) By default, GNU @code{sum} computes checksums using an algorithm compatible with BSD @code{sum} and prints file sizes in units of 1024-byte blocks. The program accepts the following options. Also see @ref{Common options}. @table @samp @item -r @opindex -r @cindex BSD @code{sum} Use the default (BSD compatible) algorithm. This option is included for compatibility with the System V @code{sum}. Unless @samp{-s} was also given, it has no effect. @item -s @itemx --sysv @opindex -s @opindex --sysv @cindex System V @code{sum} Compute checksums using an algorithm compatible with System V @code{sum}'s default, and print file sizes in units of 512-byte blocks. @end table @code{sum} is provided for compatibility; the @code{cksum} program (see next section) is preferable in new applications. @node cksum invocation @section @code{cksum}: Print CRC checksum and byte counts @pindex cksum @cindex cyclic redundancy check @cindex CRC checksum @code{cksum} computes a cyclic redundancy check (CRC) checksum for each given @var{file}, or standard input if none are given or for a @var{file} of @samp{-}. Synopsis: @example cksum [@var{option}]@dots{} [@var{file}]@dots{} @end example @code{cksum} prints the CRC checksum for each file along with the number of bytes in the file, and the filename unless no arguments were given. @code{cksum} is typically used to ensure that files have been transferred by unreliable means (e.g., netnews) have not been corrupted, by comparing the @code{cksum} output for the received files with the @code{cksum} output for the original files (typically given in the distribution). The CRC algorithm is specified by the POSIX.2 standard. It is not compatible with the BSD or System V @code{sum} algorithms (see the previous section); it is more robust. The only options are @samp{--help} and @samp{--version}. @xref{Common options}. @node md5sum invocation @section @code{md5sum}: Print or check message-digests @pindex md5sum @cindex 128-bit checksum @cindex checksum, 128-bit @cindex fingerprint, 128-bit @cindex message-digest, 128-bit @code{md5sum} computes a 128-bit checksum (or @dfn{fingerprint} or @dfn{message-digest} for each given @var{file}, or standard input if none are given or for a @var{file} of @samp{-}. It can also check if the checksum has changed. Synopsis: @example md5sum [@var{option}]@dots{} [@var{file}]@dots{} @end example For each @var{file}, @samp{md5sum} outputs the MD5 checksum, a flag indicating a binary or text input file, and the filename. The program accepts the following options. Also see @ref{Common options}. @table @samp @item -b @itemx --binary @opindex -b @opindex --binary @cindex binary input files Treat input files as binary. This makes no difference on Unix systems, but other systems have different internal and external character representations, notably to mark end-of-line. @item -c @itemx --check=@var{file} @var{file} is taken as the output of a former run of @samp{md5sum}: each line consists of an MD5 checksum, a binary/text flag, and a filename. The file will be opened (with each possible relative path) and the its message-digest computed. If this computed message digest is not the same as that given in the line, the file will be marked as failed. @item -s @itemx --string=@var{string} @opindex -s @opindex --string Compute the message digest for @var{string}, instead of for a file. The result is the same as for a file with contains exactly @var{string}. @item -t @itemx --text @opindex -t @opindex --text @cindex text input files Treat all input files as text files. This is the reverse of @samp{--binary}. @item -v @itemx --verbose @opindex -v @opindex --verbose Print progress information. @end table @node Operating on sorted files @chapter Operating on sorted files @cindex operating on sorted files @cindex sorted files, operations on These commands work with (or produce) sorted files. @menu * sort invocation:: Sort text files. * uniq invocation:: Uniqify files. * comm invocation:: Compare two sorted files line by line. @end menu @node sort invocation @section @code{sort}: Sort text files @pindex sort @cindex sorting files @code{sort} sorts, merges, or compares all the lines from the given files, or standard input if none are given or for a @var{file} of @samp{-}. By default, @code{sort} writes the results to standard output. Synopsis: @example sort [@var{option}]@dots{} [@var{file}]@dots{} @end example @code{sort} has three modes of operation: sort (the default), merge, and check for sortedness. The following options change the operation mode: @table @samp @item -c @opindex -c @cindex checking for sortedness Check whether the given files are already sorted: if they are not all sorted, print an error message and exit with a status of 1. @item -m @opindex -m @cindex merging sorted files Merge the given files by sorting them as a group. Each input file must always be individually sorted. It always works to sort instead of merge; merging is provided because it is faster, in the case where it works. @end table A pair of lines is compared as follows: if any key fields have been specified, @code{sort} compares each pair of fields, in the order specified on the command line, according to the associated ordering options, until a difference is found or no fields are left. If any of the global options @samp{Mbdfinr} are given but no key fields are specified, @code{sort} compares the entire lines according to the global options. Finally, as a last resort when all keys compare equal (or if no ordering options were specified at all), @code{sort} compares the lines byte by byte in machine collating sequence. The last resort comparison honors the @samp{-r} global option. The @samp{-s} (stable) option disables this last-resort comparison so that lines in which all fields compare equal are left in their original relative order. If no fields or global options are specified, @samp{-s} has no effect. GNU @code{sort} (as specified for all GNU utilities) has no limits on input line length or restrictions on bytes allowed within lines. In addition, if the final byte of an input file is not a newline, GNU @code{sort} silently supplies one. @vindex TMPDIR If the environment variable @code{TMPDIR} is set, @code{sort} uses its value as the directory for temporary files instead of @file{/tmp}. The @samp{-T @var{tempdir}} option in turn overrides the environment variable. The following options affect the ordering of output lines. They may be specified globally or as part of a specific key field. If no key fields are specified, global options apply to comparison of entire lines; otherwise the global options are inherited by key fields that do not specify any special options of their own. @table @samp @item -b @opindex -b @cindex blanks, ignoring leading Ignore leading blanks when finding sort keys in each line. @item -d @opindex -d @cindex phone directory order @cindex telephone directory order Sort in @dfn{phone directory} order: ignore all characters except letters, digits and blanks when sorting. @item -f @opindex -f @cindex case folding Fold lowercase characters into the equivalent uppercase characters when sorting so that, for example, @samp{b} and @samp{B} sort as equal. @item -i @opindex -i @cindex unprintable characters, ignoring Ignore characters outside the printable ASCII range 040-0176 octal (inclusive) when sorting. @item -M @opindex -M @cindex months, sorting by An initial string, consisting of any amount of whitespace, followed by three letters abbreviating a month name, is folded to UPPER case and compared in the order @samp{JAN} < @samp{FEB} < @dots{} < @samp{DEC}. Invalid names compare low to valid names. @item -n @opindex -n @cindex numeric sort Sort numerically: the number begins each line; specifically, it consists of optional whitespace, an optional @samp{-} sign, and zero or more digits, optionally followed by a decimal point and zero or more digits. @item -r @opindex -r @cindex reverse sorting Reverse the result of comparison, so that lines with greater key values appear earlier in the output instead of later. @end table Other options are: @table @samp @item -o @var{output-file} @opindex -o @cindex overwriting of input, allowed Write output to @var{output-file} instead of standard output. If @var{output-file} is one of the input files, @code{sort} copies it to a temporary file before sorting and writing the output to @var{output-file}. @item -t @var{separator} @opindex -t @cindex field separator character Use character @var{separator} as the field separator when finding the sort keys in each line. By default, fields are separated by the empty string between a non-whitespace character and a whitespace character. That is, given the input line @w{@samp{ foo bar}}, @code{sort} breaks it into fields @w{@samp{ foo}} and @w{@samp{ bar}}. The field separator is not considered to be part of either the field preceding or the field following. @item -u @opindex -u @cindex uniqifying output For the default case or the @samp{-m} option, only output the first of a sequence of lines that compare equal. For the @samp{-c} option, check that no pair of consecutive lines compares equal. @item -k @var{pos1}[,@var{pos2}] @opindex -k @cindex sort field The recommended, POSIX, option for specifying a sort field. The field consists of the line between @var{pos1} and @var{pos2} (or the end of the line, if @var{pos2} is omitted), inclusive. Fields and character positions are numbered starting with 1. See below. @item +@var{pos1}[-@var{pos2}] The obsolete, traditional option for specifying a sort field. The field consists of the line between @var{pos1} and up to but not including @var{pos2} (or the end of the line if @var{pos2} is omitted). Fields and character positions are numbered starting with 0. See below. @end table In addition, when GNU @code{sort} is invoked with exactly one argument, options @samp{--help} and @samp{--version} are recognized. @xref{Common options}. Historical (BSD and System V) implementations of @code{sort} have differed in their interpretation of some options, particularly @samp{-b}, @samp{-f}, and @samp{-n}. GNU sort follows the POSIX behavior, which is usually (but not always!) like the System V behavior. According to POSIX, @samp{-n} no longer implies @samp{-b}. For consistency, @samp{-M} has been changed in the same way. This may affect the meaning of character positions in field specifications in obscure cases. The only fix is to add an explicit @samp{-b}. A position in a sort field specified with the @samp{-k} or @samp{+} option has the form @samp{@var{f}.@var{c}}, where @var{f} is the number of the field to use and @var{c} is the number of the first character from the beginning of the field (for @samp{+@var{pos}}) or from the end of the previous field (for @samp{-@var{pos}}). If the @samp{.@var{c}} is omitted, it's taken to be the first character in the field. If the @samp{-b} option was specified, the @samp{.@var{c}} part of a field specification is counted from the first nonblank character of the field (for @samp{+@var{pos}}) or from the first nonblank character following the previous field (for @samp{-@var{pos}}). A sort key option may also have any of the option letters @samp{Mbdfinr} appended to it, in which case the global ordering options are not used for that particular field. The @samp{-b} option may be independently attached to either or both of the @samp{+@var{pos}} and @samp{-@var{pos}} parts of a field specification, and if it is inherited from the global options it will be attached to both. If a @samp{-n} or @samp{-M} option is used, thus implying a @samp{-b} option, the @samp{-b} option is taken to apply to both the @samp{+@var{pos}} and the @samp{-@var{pos}} parts of a key specification. Keys may span multiple fields. @node uniq invocation @section @code{uniq}: Uniqify files @pindex uniq @cindex uniqify files @code{uniq} writes the unique lines in the given @file{input}, or standard input if nothing is given or for an @var{input} name of @samp{-}. Synopsis: @example uniq [@var{option}]@dots{} [@var{input} [@var{output}]] @end example By default, @code{uniq} prints the unique lines in a sorted file, i.e., discards all but one of identical successive lines. Optionally, it can instead show only lines that appear exactly once, or lines that appear more than once. The input must be sorted. If your input is not sorted, perhaps you want to use @code{sort -u}. If no @var{output} file is specified, @code{uniq} writes to standard output. The program accepts the following options. Also see @ref{Common options}. @table @samp @item -@var{n} @itemx -f @var{n} @itemx --skip-fields=@var{n} @opindex -@var{n} @opindex -f @opindex --skip-fields Skip @var{n} fields on each line before checking for uniqueness. Fields are sequences of non-space non-tab characters that are separated from each other by at least one spaces or tabs. @item +@var{n} @itemx -s @var{n} @itemx --skip-chars=@var{n} @opindex +@var{n} @opindex -s @opindex --skip-chars Skip @var{n} characters before checking for uniqueness. If you use both the field and character skipping options, fields are skipped over first. @item -c @itemx --count @opindex -c @opindex --count Print the number of times each line occurred along with the line. @item -d @itemx --repeated @opindex -d @opindex --repeated @cindex duplicate lines, outputting Print only duplicate lines. @item -u @itemx --unique @opindex -u @opindex --unique @cindex unique lines, outputting Print only unique lines. @item -w @var{n} @itemx --check-chars=@var{n} @opindex -w @opindex --check-chars Compare @var{n} characters on each line (after skipping any specified fields and characters). By default the entire rest of the lines are compared. @end table @node comm invocation @section @code{comm}: Compare two sorted files line by line @pindex comm @cindex line-by-line comparison @cindex comparing sorted files @code{comm} writes to standard output lines that are common, and lines that are unique, to two input files; a file name of @samp{-} means standard input. Synopsis: @example comm [@var{option}]@dots{} @var{file1} @var{file2} @end example The input files must be sorted before @code{comm} can be used. @cindex differing lines @cindex common lines With no options, @code{comm} produces three column output. Column one contains lines unique to @var{file1}, column two contains lines unique to @var{file2}, and column three contains lines common to both files. @opindex -1 @opindex -2 @opindex -3 The options @samp{-1}, @samp{-2}, and @samp{-3} suppress printing of the corresponding columns. Also see @ref{Common options}. @node Operating on fields within a line @chapter Operating on fields within a line @menu * cut invocation:: Print selected parts of lines. * paste invocation:: Merge lines of files. * join invocation:: Join lines on a common field. @end menu @node cut invocation @section @code{cut}: Print selected parts of lines @pindex cut @code{cut} writes to standard output selected parts of each line of each input file, or standard input if no files are given or for a file name of @samp{-}. Synopsis: @example cut [@var{option}]@dots{} [@var{file}]@dots{} @end example In the table which follows, the @var{byte-list}, @var{character-list}, and @var{field-list} are one or more numbers or ranges (two numbers separated by a dash) separated by commas. Bytes, characters, and fields are numbered from starting at 1. Incomplete ranges may be given: @samp{-@var{m}} means @samp{1-@var{m}}; @samp{@var{n}-} means @samp{@var{n}} through end of line or last field. The program accepts the following options. Also see @ref{Common options}. @table @samp @item -b @var{byte-list} @itemx --bytes=@var{byte-list} @opindex -b @opindex --bytes Print only the bytes in positions listed in @var{byte-list}. Tabs and backspaces are treated like any other character; they take up 1 byte. @item -c @var{character-list} @itemx --characters=@var{character-list} @opindex -c @opindex --characters Print only characters in positions listed in @var{character-list}. The same as @samp{-b} for now, but internationalization will change that. Tabs and backspaces are treated like any other character; they take up 1 character. @item -f @var{field-list} @itemx --fields=@var{field-list} @opindex -f @opindex --fields Print only the fields listed in @var{field-list}. Fields are separated by a @key{TAB} by default. @item -d @var{delim} @itemx --delimiter=@var{delim} @opindex -d @opindex --delimiter For @samp{-f}, fields are separated by the first character in @var{delim} (default is @key{TAB}). @item -n @opindex -n Do not split multibyte characters (no-op for now). @item -s @itemx --only-delimited @opindex -s @opindex --only-delimited For @samp{-f}, do not print lines that do not contain the field separator character. @end table @node paste invocation @section @code{paste}: Merge lines of files @pindex paste @cindex merging files @code{paste} writes to standard output lines consisting of sequentially corresponding lines of each given file, separated by @key{TAB}. Standard input is used for a file name of @samp{-} or if no input files are given. Synopsis: @example paste [@var{option}]@dots{} [@var{file}]@dots{} @end example The program accepts the following options. Also see @ref{Common options}. @table @samp @item -s @itemx --serial @opindex -s @opindex --serial Paste the lines of one file at a time rather than one line from each file. @item -d @var{delim-list} @itemx --delimiters @var{delim-list} @opindex -d @opindex --delimiters Consecutively use the characters in @var{delim-list} instead of @key{TAB} to separate merged lines. When @var{delim-list} is exhausted, start again at its beginning. @end table @node join invocation @section @code{join}: Join lines on a common field @pindex join @cindex common field, joining on @code{join} writes to standard output a line for each pair of input lines that have identical join fields. Synopsis: @example join [@var{option}]@dots{} @var{file1} @var{file2} @end example Either @var{file1} or @var{file2} (but not both) can be @samp{-}, meaning standard input. @var{file1} and @var{file2} should be already sorted in increasing order (not numerically) on the join fields; unless the @samp{-t} option is given, they should be sorted ignoring blanks at the start of the line, as in @code{sort -b}. The defaults are: the join field is the first field in each line; fields in the input are separated by one or more blanks, with leading blanks on the line ignored; fields in the output are separated by a space; each output line consists of the join field, the remaining fields from @var{file1}, then the remaining fields from @var{file2}. The program accepts the following options. Also see @ref{Common options}. @table @samp @item -a @var{file-number} @opindex -a Print a line for each unpairable line in file @var{file-number} (either @samp{1} or @samp{2}), in addition to the normal output. @item -e @var{string} @opindex -e Replace those output fields that are missing in the input with @var{string}. @item -1 @var{field} @itemx -j1 @var{field} @opindex -1 @opindex -j1 Join on field @var{field} (a positive integer) of file 1. @item -2 @var{field} @itemx -j2 @var{field} @opindex -2 @opindex -j2 Join on field @var{field} (a positive integer) of file 2. @item -j @var{field} Equivalent to @samp{-1 @var{field} -2 @var{field}}. @item -o @var{field-list}@dots{} Construct each output line according to the format in @var{field-list}. Each element in @var{field-list} consists of a file number (either 1 or 2), a period, and a field number (a positive integer). The elements in the list are separated by commas or blanks. Multiple @var{field-list} arguments can be given after a single @samp{-o} option; the values of all lists given with @samp{-o} are concatenated together. @item -t @var{char} Use character @var{char} as the input and output field separator. @item -v @var{file-number} Print a line for each unpairable line in file @var{file-number} (either 1 or 2), instead of the normal output. @end table In addition, when GNU @code{join} is invoked with exactly one argument, options @samp{--help} and @samp{--version} are recognized. @xref{Common options}. @node Operating on characters @chapter Operating on characters @cindex operating on characters This commands operate on individual characters. @menu * tr invocation:: Translate, squeeze, and/or delete characters. * expand invocation:: Convert tabs to spaces. * unexpand invocation:: Convert spaces to tabs. @end menu @node tr invocation @section @code{tr}: Translate, squeeze, and/or delete characters @pindex tr Synopsis: @example tr [@var{option}]@dots{} @var{set1} [@var{set2}] @end example @code{tr} copies standard input to standard output, performing one of the following operations: @itemize @bullet @item translate, and optionally squeeze repeated characters in the result, @item squeeze repeated characters, @item delete characters, @item delete characters, then squeeze repeated characters from the result. @end itemize The @var{set1} and (if given) @var{set2} arguments define ordered sets of characters, referred to below as @var{set1} and @var{set2}. These sets are the characters of the input that @code{tr} operates on. The @samp{--complement} (@samp{-c}) option replaces @var{set1} with its complement (all of the characters that are not in @var{set1}). @menu * Character sets:: Specifying sets of characters. * Translating:: Changing one characters to another. * Squeezing:: Squeezing repeats and deleting. * Warnings in tr:: Warning messages. @end menu @node Character sets @subsection Specifying sets of characters @cindex specifying sets of characters The format of the @var{set1} and @var{set2} arguments resembles the format of regular expressions; however, they are not regular expressions, only lists of characters. Most characters simply represent themselves in these strings, but the strings can contain the shorthands listed below, for convenience. Some of them can be used only in @var{set1} or @var{set2}, as noted below. @table @asis @item Backslash escapes. @cindex backslash escapes A backslash followed by a character not listed below causes an error message. @table @samp @item \a Control-G, @item \b Control-H, @item \f Control-L, @item \n Control-J, @item \r Control-M, @item \t Control-I, @item \v Control-K, @item \@var{ooo} The character with the value given by @var{ooo}, which is 1 to 3 octal digits, @item \\ A backslash. @end table @item Ranges. @cindex ranges The notation @samp{@var{m}-@var{n}} expands to all of the characters from @var{m} through @var{n}, in ascending order. @var{m} should collate before @var{n}; if it doesn't, an error results. As an example, @samp{0-9} is the same as @samp{0123456789}. Although GNU @code{tr} does not support the System V syntax that uses square brackets to enclose ranges, translations specified in that format will still work as long as the brackets in @var{string1} correspond to identical brackets in @var{string2}. @item Repeated characters. @cindex repeated characters The notation @samp{[@var{c}*@var{n}]} in @var{set2} expands to @var{n} copies of character @var{c}. Thus, @samp{[y*6]} is the same as @samp{yyyyyy}. The notation @samp{[@var{c}*]} in @var{string2} expands to as many copies of @var{c} as are needed to make @var{set2} as long as @var{set1}. If @var{n} begins with @samp{0}, it is interpreted in octal, otherwise in decimal. @item Character classes. @cindex characters classes The notation @samp{[:@var{class}:]} expands to all of the characters in the (predefined) class @var{class}. The characters expand in no particular order, except for the @code{upper} and @code{lower} classes, which expand in ascending order. When the @samp{--delete} (@samp{-d}) and @samp{--squeeze-repeats} (@samp{-s}) options are both given, any character class can be used in @var{set2}. Otherwise, only the character classes @code{lower} and @code{upper} are accepted in @var{set2}, and then only if the corresponding character class (@code{upper} and @code{lower}, respectively) is specified in the same relative position in @var{set1}. Doing this specifies case conversion. The class names are given below; an error results when an invalid class name is given. @table @code @item alnum @opindex alnum Letters and digits. @item alpha @opindex alpha Letters. @item blank @opindex blank Horizontal whitespace. @item cntrl @opindex cntrl Control characters. @item digit @opindex digit Digits. @item graph @opindex graph Printable characters, not including space. @item lower @opindex lower Lowercase letters. @item print @opindex print Printable characters, including space. @item punct @opindex punct Punctuation characters. @item space @opindex space Horizontal or vertical whitespace. @item upper @opindex upper Uppercase letters. @item xdigit @opindex xdigit Hexadecimal digits. @end table @item Equivalence classes. @cindex equivalence classes The syntax @samp{[=@var{c}=]} expands to all of the characters that are equivalent to @var{c}, in no particular order. Equivalence classes are a relatively recent invention intended to support non-English alphabets. But there seems to be no standard way to define them or determine their contents. Therefore, they are not fully implemented in GNU @code{tr}; each character's equivalence class consists only of that character, which is of no particular use. @end table @node Translating @subsection Translating @cindex translating characters @code{tr} performs translation when @var{set1} and @var{set2} are both given and the @samp{--delete} (@samp{-d}) option is not given. @code{tr} translates each character of its input that is in @var{set1} to the corresponding character in @var{set2}. Characters not in @var{set1} are passed through unchanged. When a character appears more than once in @var{set1} and the corresponding characters in @var{set2} are not all the same, only the final one is used. For example, these two commands are equivalent: @example tr aaa xyz tr a z @end example A common use of @code{tr} is to convert lowercase characters to uppercase. This can be done in many ways. Here are three of them: @example tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ tr a-z A-Z tr '[:lower:]' '[:upper:]' @end example When @code{tr} is performing translation, @var{set1} and @var{set2} typically have the same length. If @var{set1} is shorter than @var{set2}, the extra characters at the end of @var{set2} are ignored. On the other hand, making @var{set1} longer than @var{set2} is not portable; POSIX.2 says that the result is undefined. In this situation, BSD @code{tr} pads @var{set2} to the length of @var{set1} by repeating the last character of @var{set2} as many times as necessary. System V @code{tr} truncates @var{set1} to the length of @var{set2}. By default, GNU @code{tr} handles this case like BSD @code{tr}. When the @samp{--truncate-set1} (@samp{-t}) option is given, GNU @code{tr} handles this case like the System V @code{tr} instead. This option is ignored for operations other than translation. Acting like System V @code{tr} in this case breaks the relatively common BSD idiom: @example tr -cs A-Za-z0-9 '\012' @end example @noindent because it converts only zero bytes (the first element in the complement of @var{set1}), rather than all non-alphanumerics, to newlines. @node Squeezing @subsection Squeezing repeats and deleting @cindex squeezing repeat characters @cindex deleting characters When given just the @samp{--delete} (@samp{-d}) option, @code{tr} removes any input characters that are in @var{set1}. When given just the @samp{--squeeze-repeats} (@samp{-s}) option, @code{tr} replaces each input sequence of a repeated character that is in @var{set1} with a single occurrence of that character. When given both @samp{--delete} and @samp{--squeeze-repeats}, @code{tr} first performs any deletions using @var{set1}, then squeezes repeats from any remaining characters using @var{set2}. The @samp{--squeeze-repeats} option may also be used when translating, in which case @code{tr} first performs translation, then squeezes repeats from any remaining characters using @var{set2}. Here are some examples to illustrate various combinations of options: @itemize @bullet @item Remove all zero bytes: @example tr -d '\000' @end example @item Put all words on lines by themselves. This converts all non-alphanumeric characters to newlines, then squeezes each string of repeated newlines into a single newline: @example tr -cs '[a-zA-Z0-9]' '[\n*]' @end example @item Convert each sequence of repeated newlines to a single newline: @example tr -s '\n' @end example @end itemize @node Warnings in tr @subsection Warning messages @vindex POSIXLY_CORRECT Setting the environment variable @code{POSIXLY_CORRECT} turns off the following warning and error messages, for strict compliance with POSIX.2. Otherwise, the following diagnostics are issued: @enumerate @item When the @samp{--delete} option is given but @samp{--squeeze-repeats} is not, and @var{set2} is given, GNU @code{tr} by default prints a usage message and exits, because @var{set2} would not be used. The POSIX specification says that @var{set2} must be ignored in this case. Silently ignoring arguments is a bad idea. @item When an ambiguous octal escape is given. For example, @samp{\400} is actually @samp{\40} followed by the digit @samp{0}, because the value 400 octal does not fit into a single byte. @end enumerate GNU @code{tr} does not provide complete BSD or System V compatibility. For example, it is impossible to disable interpretation of the POSIX constructs @samp{[:alpha:]}, @samp{[=c=]}, and @samp{[c*10]}. Also, GNU @code{tr} does not delete zero bytes automatically, unlike traditional Unix versions, which provide no way to preserve zero bytes. @node expand invocation @section @code{expand}: Convert tabs to spaces @pindex expand @cindex tabs to spaces, converting @cindex converting tabs to spaces @code{expand} writes the contents of each given @var{file}, or standard input if none are given or for a @var{file} of @samp{-}, to standard output, with tab characters converted to the appropriate number of spaces. Synopsis: @example expand [@var{option}]@dots{} [@var{file}]@dots{} @end example By default, @code{expand} converts all tabs to spaces. It preserves backspace characters in the output; they decrement the column count for tab calculations. The default action is equivalent to @samp{-8} (set tabs every 8 columns). The program accepts the following options. Also see @ref{Common options}. @table @samp @item -@var{tab1}[,@var{tab2}]@dots{} @itemx -t @var{tab1}[,@var{tab2}]@dots{} @itemx --tabs=@var{tab1}[,@var{tab2}]@dots{} @opindex -@var{tab} @opindex -t @opindex --tabs @cindex tabstops, setting If only one tab stop is given, set the tabs @var{tab1} spaces apart (default is 8). Otherwise, set the tabs at columns @var{tab1}, @var{tab2}, @dots{} (numbered from 0), and replace any tabs beyond the last tabstop given with single spaces. If the tabstops are specified with the @samp{-t} or @samp{--tabs} option, they can be separated by blanks as well as by commas. @item -i @itemx --initial @opindex -i @opindex --initial @cindex initial tabs, converting Only convert initial tabs (those that precede all non-space or non-tab characters) on each line to spaces. @end table @node unexpand invocation @section @code{unexpand}: Convert spaces to tabs @pindex unexpand @code{unexpand} writes the contents of each given @var{file}, or standard input if none are given or for a @var{file} of @samp{-}, to standard output, with strings of two or more space or tab characters converted to as many tabs as possible followed by as many spaces as are needed. Synopsis: @example unexpand [@var{option}]@dots{} [@var{file}]@dots{} @end example By default, @code{unexpand} converts only initial spaces and tabs (those that precede all non space or tab characters) on each line. It preserves backspace characters in the output; they decrement the column count for tab calculations. By default, tabs are set at every 8th column. The program accepts the following options. Also see @ref{Common options}. @table @samp @item -@var{tab1}[,@var{tab2}]@dots{} @itemx -t @var{tab1}[,@var{tab2}]@dots{} @itemx --tabs=@var{tab1}[,@var{tab2}]@dots{} @opindex -@var{tab} @opindex -t @opindex --tabs If only one tab stop is given, set the tabs @var{tab1} spaces apart instead of the default 8. Otherwise, set the tabs at columns @var{tab1}, @var{tab2}, @dots{} (numbered from 0), and leave spaces and tabs beyond the tabstops given unchanged. If the tabstops are specified with the @samp{-t} or @samp{--tabs} option, they can be separated by blanks as well as by commas. This option implies the @samp{-a} option. @item -a @itemx --all @opindex -a @opindex --all Convert all strings of two or more spaces or tabs, not just initial ones, to tabs. @end table @c What's GNU? @c Arnold Robbins @node Opening the software toolbox @chapter Opening the software toolbox This chapter originally appeared in @cite{Linux Journal}, volume 1, number 2, in the @cite{What's GNU?} column. It was written by Arnold Robbins. @menu * Toolbox introduction:: * I/O redirection:: * The @code{who} command:: * The @code{cut} command:: * The @code{sort} command:: * The @code{uniq} command:: * Putting the tools together:: @end menu @node Toolbox introduction @unnumberedsec Toolbox introduction This month's column is only peripherally related to the GNU Project, in that it describes a number of the GNU tools on your Linux system and how they might be used. What it's really about is the ``Software Tools'' philosophy of program development and usage. The software tools philosophy was an important and integral concept in the initial design and development of Unix (of which Linux and GNU are essentially clones). Unfortunately, in the modern day press of Internetworking and flashy GUIs, it seems to have fallen by the wayside. This is a shame, since it provides a powerful mental model for solving many kinds of problems. Many people carry a Swiss Army knife around in their pants pockets (or purse). A Swiss Army knife is a handy tool to have: it has several knife blades, a screwdriver, tweezers, toothpick, nail file, corkscrew, and perhaps a number of other things on it. For the everyday, small miscellaneous jobs where you need a simple, general purpose tool, it's just the thing. On the other hand, an experienced carpenter doesn't build a house using a Swiss Army knife. Instead, he has a toolbox chock full of specialized tools---a saw, a hammer, a screwdriver, a plane, and so on. And he knows exactly when and where to use each tool; you won't catch him hammering nails with the handle of his screwdriver. The Unix developers at Bell Labs were all professional programmers and trained computer scientists. They had found that while a one-size-fits-all program might appeal to a user because there's only one program to use, in practice such programs are @enumerate a @item difficult to write, @item difficult to maintain and debug, and @item difficult to extend to meet new situations. @end enumerate Instead, they felt that programs should be specialized tools. In short, each program ``should do one thing well.'' No more and no less. Such programs are simpler to design, write, and get right---they only do one thing. Furthermore, they found that with the right machinery for hooking programs together, that the whole was greater than the sum of the parts. By combining several special purpose programs, you could accomplish a specific task that none of the programs was designed for, and accomplish it much more quickly and easily than if you had to write a special purpose program. We will see some (classic) examples of this further on in the column. (An important additional point was that, if necessary, take a detour and build any software tools you may need first, if you don't already have something appropriate in the toolbox.) @node I/O redirection @unnumberedsec I/O redirection Hopefully, you are familiar with the basics of I/O redirection in the shell, in particular the concepts of ``standard input,'' ``standard output,'' and ``standard error''. Briefly, ``standard input'' is a data source, where data comes from. A program should not need to either know or care if the data source is a disk file, a keyboard, a magnetic tape, or even a punched card reader. Similarly, ``standard output'' is a data sink, where data goes to. The program should neither know nor care where this might be. Programs that only read their standard input, do something to the data, and then send it on, are called ``filters'', by analogy to filters in a water pipeline. With the Unix shell, it's very easy to set up data pipelines: @example program_to_create_data | filter1 | .... | filterN > final.pretty.data @end example We start out by creating the raw data; each filter applies some successive transformation to the data, until by the time it comes out of the pipeline, it is in the desired form. This is fine and good for standard input and standard output. Where does the standard error come in to play? Well, think about @code{filter1} in the pipeline above. What happens if it encounters an error in the data it sees? If it writes an error message to standard output, it will just disappear down the pipeline into @code{filter2}'s input, and the user will probably never see it. So programs need a place where they can send error messages so that the user will notice them. This is standard error, and it is usually connected to your console or window, even if you have redirected standard output of your program away from your screen. For filter programs to work together, the format of the data has to be agreed upon. The most straightforward and easiest format to use is simply lines of text. Unix data files are generally just streams of bytes, with lines delimited by the @sc{ASCII} @sc{LF} (Line Feed) character, conventionally called a ``newline'' in the Unix literature. (This is @code{'\n'} if you're a C programmer.) This is the format used by all the traditional filtering programs. (Many earlier operating systems had elaborate facilities and special purpose programs for managing binary data. Unix has always shied away from such things, under the philosophy that it's easiest to simply be able to view and edit your data with a text editor.) OK, enough introduction. Let's take a look at some of the tools, and then we'll see how to hook them together in interesting ways. In the following discussion, we will only present those command line options that interest us. As you should always do, double check your system documentation for the full story. @node The @code{who} command @unnumberedsec The @code{who} command The first program is the @code{who} command. By itself, it generates a list of the users who are currently logged in. Although I'm writing this on a single-user system, we'll pretend that several people are logged in: @example $ who arnold console Jan 22 19:57 miriam ttyp0 Jan 23 14:19(:0.0) bill ttyp1 Jan 21 09:32(:0.0) arnold ttyp2 Jan 23 20:48(:0.0) @end example Here, the @samp{$} is the usual shell prompt, at which I typed @code{who}. There are three people logged in, and I am logged in twice. On traditional Unix systems, user names are never more than eight characters long. This little bit of trivia will be useful later. The output of @code{who} is nice, but the data is not all that exciting. @node The @code{cut} command @unnumberedsec The @code{cut} command The next program we'll look at is the @code{cut} command. This program cuts out columns or fields of input data. For example, we can tell it to print just the login name and full name from the @file{/etc/passwd file}. The @file{/etc/passwd} file has seven fields, separated by colons: @example arnold:xyzzy:2076:10:Arnold D. Robbins:/home/arnold:/bin/ksh @end example To get the first and fifth fields, we would use cut like this: @example $ cut -d: -f1,5 /etc/passwd root:Operator @dots{} arnold:Arnold D. Robbins miriam:Miriam A. Robbins @dots{} @end example With the @samp{-c} option, @code{cut} will cut out specific characters (i.e., columns) in the input lines. This command looks like it might be useful for data filtering. @node The @code{sort} command @unnumberedsec The @code{sort} command Next we'll look at the @code{sort} command. This is one of the most powerful commands on a Unix-style system; one that you will often find yourself using when setting up fancy data plumbing. The @code{sort} command reads and sorts each file named on the command line. It then merges the sorted data and writes it to standard output. It will read standard input if no files are given on the command line (thus making it into a filter). The sort is based on the machine collating sequence (@sc{ASCII}) or based on user-supplied ordering criteria. @node The @code{uniq} command @unnumberedsec The @code{uniq} command Finally (at least for now), we'll look at the @code{uniq} program. When sorting data, you will often end up with duplicate lines, lines that are identical. Usually, all you need is one instance of each line. This is where @code{uniq} comes in. The @code{uniq} program reads its standard input, which it expects to be sorted. It only prints out one copy of each duplicated line. It does have several options. Later on, we'll use the @samp{-c} option, which prints each unique line, preceded by a count of the number of times that line occurred in the input. @node Putting the tools together @unnumberedsec Putting the tools together Now, let's suppose this is a large BBS system with dozens of users logged in. The management wants the SysOp to write a program that will generate a sorted list of logged in users. Furthermore, even if a user is logged in multiple times, his or her name should only show up in the output once. The SysOp could sit down with the system documentation and write a C program that did this. It would take perhaps a couple of hundred lines of code and about two hours to write it, test it, and debug it. However, knowing the software toolbox, the SysOp can instead start out by generating just a list of logged on users: @example $ who | cut -c1-8 arnold miriam bill arnold @end example Next, sort the list: @example $ who | cut -c1-8 | sort arnold arnold bill miriam @end example Finally, run the sorted list through @code{uniq}, to weed out duplicates: @example $ who | cut -c1-8 | sort | uniq arnold bill miriam @end example The @code{sort} command actually has a @samp{-u} option that does what @code{uniq} does. However, @code{uniq} has other uses for which one cannot substitute @samp{sort -u}. The SysOp puts this pipeline into a shell script, and makes it available for all the users on the system: @example # cat > /usr/local/bin/listusers who | cut -c1-8 | sort | uniq ^D # chmod +x /usr/local/bin/listusers @end example There are four major points to note here. First, with just four programs, on one command line, the SysOp was able to save about two hours worth of work. Furthermore, the shell pipeline is just about as efficient as the C program would be, and it is much more efficient in terms of programmer time. People time is much more expensive than computer time, and in our modern ``there's never enough time to do everything'' society, saving two hours of programmer time is no mean feat. Second, it is also important to emphasize that with the @emph{combination} of the tools, it is possible to do a special purpose job never imagined by the authors of the individual programs. Third, it is also valuable to build up your pipeline in stages, as we did here. This allows you to view the data at each stage in the pipeline, which helps you acquire the confidence that you are indeed using these tools correctly. Finally, by bundling the pipeline in a shell script, other users can use your command, without having to remember the fancy plumbing you set up for them. In terms of how you run them, shell scripts and compiled programs are indistinguishable. After the previous warm-up exercise, we'll look at two additional, more complicated pipelines. For them, we need to introduce two more tools. The first is the @code{tr} command, which stands for ``transliterate.'' The @code{tr} command works on a character-by-character basis, changing characters. Normally it is used for things like mapping upper case to lower case: @example $ echo ThIs ExAmPlE HaS MIXED case! | tr '[A-Z]' '[a-z]' this example has mixed case! @end example There are several options of interest: @table @samp @item -c work on the complement of the listed characters, i.e., operations apply to characters not in the given set @item -d delete characters in the first set from the output @item -s squeeze repeated characters in the output into just one character. @end table We will be using all three options in a moment. The other command we'll look at is @code{comm}. The @code{comm} command takes two sorted input files as input data, and prints out the files' lines in three columns. The output columns are the data lines unique to the first file, the data lines unique to the second file, and the data lines that are common to both. The @samp{-1}, @samp{-2}, and @samp{-3} command line options omit the respective columns. (This is non-intuitive and takes a little getting used to.) For example: @example $ cat f1 11111 22222 33333 44444 $ cat f2 00000 22222 33333 55555 $ comm f1 f2 00000 11111 22222 33333 44444 55555 @end example The single dash as a filename tells @code{comm} to read standard input instead of a regular file. Now we're ready to build a fancy pipeline. The first application is a word frequency counter. This helps an author determine if he or she is over-using certain words. The first step is to change the case of all the letters in our input file to one case. ``The'' and ``the'' are the same word when doing counting. @example $ tr '[A-Z]' '[a-z]' < whats.gnu | ... @end example The next step is to get rid of punctuation. Quoted words and unquoted words should be treated identically; it's easiest to just get the punctuation out of the way. @example $ tr '[A-Z]' '[a-z]' < whats.gnu | tr -cd '[A-Za-z0-9_ \012]' | ... @end example The second @code{tr} command operates on the complement of the listed characters, which are all the letters, the digits, the underscore, and the blank. The @samp{\012} represents the newline character; it has to be left alone. (The ASCII TAB character should also be included for good measure in a production script.) At this point, we have data consisting of words separated by blank space. The words only contain alphanumeric characters (and the underscore). The next step is break the data apart so that we have one word per line. This makes the counting operation much easier, as we will see shortly. @example $ tr '[A-Z]' '[a-z]' < whats.gnu | tr -cd '[A-Za-z0-9_ \012]' | > tr -s '[ ]' '\012' | ... @end example This command turns blanks into newlines. The @samp{-s} option squeezes multiple newline characters in the output into just one. This helps us avoid blank lines. (The @samp{>} is the shell's ``secondary prompt.'' This is what the shell prints when it notices you haven't finished typing in all of a command.) We now have data consisting of one word per line, no punctuation, all one case. We're ready to count each word: @example $ tr '[A-Z]' '[a-z]' < whats.gnu | tr -cd '[A-Za-z0-9_ \012]' | > tr -s '[ ]' '\012' | sort | uniq -c | ... @end example At this point, the data might look something like this: @example 60 a 2 able 6 about 1 above 2 accomplish 1 acquire 1 actually 2 additional @end example The output is sorted by word, not by count! What we want is the most frequently used words first. Fortunately, this is easy to accomplish, with the help of two more @code{sort} options: @table @samp @item -n do a numeric sort, not an ASCII one @item -r reverse the order of the sort @end table The final pipeline looks like this: @example $ tr '[A-Z]' '[a-z]' < whats.gnu | tr -cd '[A-Za-z0-9_ \012]' | > tr -s '[ ]' '\012' | sort | uniq -c | sort -nr 156 the 60 a 58 to 51 of 51 and ... @end example Whew! That's a lot to digest. Yet, the same principles apply. With six commands, on two lines (really one long one split for convenience), we've created a program that does something interesting and useful, in much less time than we could have written a C program to do the same thing. A minor modification to the above pipeline can give us a simple spelling checker! To determine if you've spelled a word correctly, all you have to do is look it up in a dictionary. If it is not there, then chances are that your spelling is incorrect. So, we need a dictionary. If you have the Slackware Linux distribution, you have the file @file{/usr/lib/ispell/ispell.words}, which is a sorted, 38,400 word dictionary. Now, how to compare our file with the dictionary? As before, we generate a sorted list of words, one per line: @example $ tr '[A-Z]' '[a-z]' < whats.gnu | tr -cd '[A-Za-z0-9_ \012]' | > tr -s '[ ]' '\012' | sort -u | ... @end example Now, all we need is a list of words that are @emph{not} in the dictionary. Here is where the @code{comm} command comes in. @example $ tr '[A-Z]' '[a-z]' < whats.gnu | tr -cd '[A-Za-z0-9_ \012]' | > tr -s '[ ]' '\012' | sort -u | > comm -23 - /usr/lib/ispell/ispell.words @end example The @samp{-2} and @samp{-3} options eliminate lines that are only in the dictionary (the second file), and lines that are in both files. Lines only in the first file (standard input, our stream of words), are words that are not in the dictionary. These are likely candidates for spelling errors. This pipeline was the first cut at a production spelling checker on Unix. There are some other tools that deserve brief mention. @table @code @item grep search files for text that matches a regular expression @item egrep like @code{grep}, but with more powerful regular expressions @item wc count lines, words, characters @item tee a T-fitting for data pipes, copies data to files and to standard output @item sed the stream editor, an advanced tool @item awk a data manipulation language, another advanced tool @end table The software tools philosophy also espoused the following bit of advice: ``Let someone else do the hard part.'' This means, take something that gives you most of what you need, and then massage it the rest of the way until it's in the form that you want. To summarize: @enumerate 1 @item Each program should do one thing well. No more, no less. @item Combining programs with appropriate plumbing leads to results where the whole is greater than the sum of the parts. It also leads to novel uses of programs that the authors might never have imagined. @item Programs should never print extraneous header or trailer data, since these could get sent on down a pipeline. (A point we didn't mention earlier.) @item Let someone else do the hard part. @item Know your toolbox! Use each program appropriately. If you don't have an appropriate tool, build one. @end enumerate As of this writing, all the programs we've discussed are available via anonymous @code{ftp} from @code{prep.ai.mit.edu} as @file{/pub/gnu/textutils-1.9.tar.gz} directory.@footnote{Version 1.9 was current when this column was written. Check the nearest GNU archive for the current version.} None of what I have presented in this column is new. The Software Tools philosophy was first introduced in the book @cite{Software Tools}, by Brian Kernighan and P.J. Plauger (Addison-Wesley, ISBN 0-201-03669-X). This book showed how to write and use software tools. It was written in 1976, using a preprocessor for FORTRAN named @code{ratfor} (RATional FORtran). At the time, C was not as ubiquitous as it is now; FORTRAN was. The last chapter presented a @code{ratfor} to FORTRAN processor, written in @code{ratfor}. @code{ratfor} looks an awful lot like C; if you know C, you won't have any problem following the code. In 1981, the book was updated and made available as @cite{Software Tools in Pascal} (Addison-Wesley, ISBN 0-201-10342-7). Both books remain in print, and are well worth reading if you're a programmer. They certainly made a major change in how I view programming. Initially, the programs in both books were available (on 9-track tape) from Addison-Wesley. Unfortunately, this is no longer the case, although you might be able to find copies floating around the Internet. For a number of years, there was an active Software Tools Users Group, whose members had ported the original @code{ratfor} programs to essentially every computer system with a FORTRAN compiler. The popularity of the group waned in the middle '80s as Unix began to spread beyond universities. With the current proliferation of GNU code and other clones of Unix programs, these programs now receive little attention; modern C versions are much more efficient and do more than these programs do. Nevertheless, as exposition of good programming style, and evangelism for a still-valuable philosophy, these books are unparalleled, and I recommend them highly. Acknowledgement: I would like to express my gratitude to Brian Kernighan of Bell Labs, the original Software Toolsmith, for reviewing this column. @node Index @unnumbered Index @printindex cp @contents @bye @c Local variables: @c texinfo-column-for-description: 32 @c End: textutils-1.12/doc/textutils.info100644 74504 13 333444 5770372306 16333 0ustar meyeringuserThis is Info file textutils.info, produced by Makeinfo-1.60 from the input file textutils.texi. START-INFO-DIR-ENTRY * Text utilities: (textutils). GNU text utilities. * cat: (textutils)cat invocation. Concatenate and write files. * cksum: (textutils)cksum invocation. Print POSIX CRC checksum. * comm: (textutils)comm invocation. Compare sorted files by line. * csplit: (textutils)csplit invocation. Split by context. * cut: (textutils)cut invocation. Print selected parts of lines. * expand: (textutils)expand invocation. Convert tabs to spaces. * fmt: (textutils)fmt invocation. Reformat paragraph text. * fold: (textutils)fold invocation. Wrap long input lines. * head: (textutils)head invocation. Output the first part of files. * join: (textutils)join invocation. Join lines on a common field. * md5sum: (textutils)md5sum invocation. Print or check message-digests. * nl: (textutils)nl invocation. Number lines and write files. * od: (textutils)od invocation. Dump files in octal, etc. * paste: (textutils)paste invocation. Merge lines of files. * pr: (textutils)pr invocation. Paginate or columnate files. * sort: (textutils)sort invocation. Sort text files. * split: (textutils)split invocation. Split into fixed-size pieces. * sum: (textutils)sum invocation. Print traditional checksum. * tac: (textutils)tac invocation. Reverse files. * tail: (textutils)tail invocation. Output the last part of files. * tr: (textutils)tr invocation. Translate characters. * unexpand: (textutils)unexpand invocation. Convert spaces to tabs. * uniq: (textutils)uniq invocation. Uniqify files. * wc: (textutils)wc invocation. Byte, word, and line counts. END-INFO-DIR-ENTRY This file documents the GNU text utilities. Copyright (C) 1994, 95 Free Software Foundation, Inc. Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that this permission notice may be stated in a translation approved by the Foundation.  File: textutils.info, Node: Top, Up: (dir) GNU text utilities ****************** This manual minimally documents version 1.12 of the GNU text utilities. * Menu: * Introduction:: Caveats, overview, and authors. * Common options:: Common options. * Output of entire files:: cat tac nl od * Formatting file contents:: fmt pr fold * Output of parts of files:: head tail split csplit * Summarizing files:: wc sum cksum md5sum * Operating on sorted files:: sort uniq comm * Operating on fields within a line:: cut paste join * Operating on characters:: tr expand unexpand * Opening the software toolbox:: The software tools philosophy. * Index:: General index.  File: textutils.info, Node: Introduction, Next: Common options, Prev: Top, Up: Top Introduction ************ This manual is incomplete: No attempt is made to explain basic concepts in a way suitable for novices. Thus, if you are interested, please get involved in improving this manual. The entire GNU community will benefit. The GNU text utilities are mostly compatible with the POSIX.2 standard. Please report bugs to `bug-gnu-utils@prep.ai.mit.edu'. Remember to include the version number, machine architecture, input files, and any other information needed to reproduce the bug: your input, what you expected, what you got, and why it is wrong. Diffs are welcome, but please include a description of the problem as well, since this is sometimes difficult to infer. *Note Bugs: (gcc)Bugs. This manual is based on the Unix man pages in the distribution, which were originally written by David MacKenzie and updated by Jim Meyering. The original `fmt' man page was written by Ross Paterson. Franc,ois Pinard did the initial conversion to Texinfo format. Karl Berry did the indexing, some reorganization, and editing of the results. Richard Stallman contributed his usual invaluable insights to the overall process.  File: textutils.info, Node: Common options, Next: Output of entire files, Prev: Introduction, Up: Top Common options ************** Certain options are available in all these programs. Rather than writing identical descriptions for each of the programs, they are described here. (In fact, every GNU program accepts (or should accept) these options.) A few of these programs take arbitrary strings as arguments. In those cases, `--help' and `--version' are taken as these options only if there is one and exactly one command line argument. `--help' Print a usage message listing all available options, then exit successfully. `--version' Print the version number, then exit successfully.  File: textutils.info, Node: Output of entire files, Next: Formatting file contents, Prev: Common options, Up: Top Output of entire files ********************** These commands read and write entire files, possibly transforming them in some way. * Menu: * cat invocation:: Concatenate and write files. * tac invocation:: Concatenate and write files in reverse. * nl invocation:: Number lines and write files. * od invocation:: Write files in octal or other formats.  File: textutils.info, Node: cat invocation, Next: tac invocation, Up: Output of entire files `cat': Concatenate and write files ================================== `cat' copies each FILE (`-' means standard input), or standard input if none are given, to standard output. Synopsis: cat [OPTION] [FILE]... The program accepts the following options. Also see *Note Common options::. `-A' `--show-all' Equivalent to `-vET'. `-b' `--number-nonblank' Number all nonblank output lines, starting with 1. `-e' Equivalent to `-vE'. `-E' `--show-ends' Display a `$' after the end of each line. `-n' `--number' Number all output lines, starting with 1. `-s' `--squeeze-blank' Replace multiple adjacent blank lines with a single blank line. `-t' Equivalent to `-vT'. `-T' `--show-tabs' Display TAB characters as `^I'. `-u' Ignored; for Unix compatibility. `-v' `--show-nonprinting' Display control characters except for LFD and TAB using `^' notation and precede characters that have the high bit set with `M-'.  File: textutils.info, Node: tac invocation, Next: nl invocation, Prev: cat invocation, Up: Output of entire files `tac': Concatenate and write files in reverse ============================================= `tac' copies each FILE (`-' means standard input), or standard input if none are given, to standard output, reversing the records (lines by default) in each separately. Synopsis: tac [OPTION]... [FILE]... "Records" are separated by instances of a string (newline by default). By default, this separator string is attached to the end of the record that it follows in the file. The program accepts the following options. Also see *Note Common options::. `-b' `--before' The separator is attached to the beginning of the record that it precedes in the file. `-r' `--regex' Treat the separator string as a regular expression. `-s SEPARATOR' `--separator=SEPARATOR' Use SEPARATOR as the record separator, instead of newline.  File: textutils.info, Node: nl invocation, Next: od invocation, Prev: tac invocation, Up: Output of entire files `nl': Number lines and write files ================================== `nl' writes each FILE (`-' means standard input), or standard input if none are given, to standard output, with line numbers added to some or all of the lines. Synopsis: nl [OPTION]... [FILE]... `nl' decomposes its input into (logical) pages; by default, the line number is reset to 1 at the top of each logical page. `nl' treats all of the input files as a single document; it does not reset line numbers or logical pages between files. A logical page consists of three sections: header, body, and footer. Any of the sections can be empty. Each can be numbered in a different style from the others. The beginnings of the sections of logical pages are indicated in the input file by a line containing exactly one of these delimiter strings: `\:\:\:' start of header; `\:\:' start of body; `\:' start of footer. The two characters from which these strings are made can be changed from `\' and `:' via options (see below), but the pattern and length of each string cannot be changed. A section delimiter is replaced by an empty line on output. Any text that comes before the first section delimiter string in the input file is considered to be part of a body section, so `nl' treats a file that contains no section delimiters as a single body section. The program accepts the following options. Also see *Note Common options::. `-b STYLE' `--body-numbering=STYLE' Select the numbering style for lines in the body section of each logical page. When a line is not numbered, the current line number is not incremented, but the line number separator character is still prepended to the line. The styles are: `a' number all lines, `t' number only nonempty lines (default for body), `n' do not number lines (default for header and footer), `pREGEXP' number only lines that contain a match for REGEXP. `-d CD' `--section-delimiter=CD' Set the section delimiter characters to CD; default is `\:'. If only C is given, the second remains `:'. (Remember to protect `\' or other metacharacters from shell expansion with quotes or extra backslashes.) `-f STYLE' `--footer-numbering=STYLE' Analogous to `--body-numbering'. `-h STYLE' `--header-numbering=STYLE' Analogous to `--body-numbering'. `-i NUMBER' `--page-increment=NUMBER' Increment line numbers by NUMBER (default 1). `-l NUMBER' `--join-blank-lines=NUMBER' Consider NUMBER (default 1) consecutive empty lines to be one logical line for numbering, and only number the last one. Where fewer than NUMBER consecutive empty lines occur, do not number them. An empty line is one that contains no characters, not even spaces or tabs. `-n FORMAT' `--number-format=FORMAT' Select the line numbering format (default is `rn'): `ln' left justified, no leading zeros; `rn' right justified, no leading zeros; `rz' right justified, leading zeros. `-p' `--no-renumber' Do not reset the line number at the start of a logical page. `-s STRING' `--number-separator=STRING' Separate the line number from the text line in the output with STRING (default is TAB). `-v NUMBER' `--first-page=NUMBER' Set the initial line number on each logical page to NUMBER (default 1). `-w NUMBER' `--number-width=NUMBER' Use NUMBER characters for line numbers (default 6).  File: textutils.info, Node: od invocation, Prev: nl invocation, Up: Output of entire files `od': Write files in octal or other formats =========================================== `od' writes an unambiguous representation of each FILE (`-' means standard input), or standard input if none are given. Synopsis: od [OPTION]... [FILE]... od -C [FILE] [[+]OFFSET [[+]LABEL]] Each line of output consists of the offset in the input, followed by groups of data from the file. By default, `od' prints the offset in octal, and each group of file data is two bytes of input printed as a single octal number. The program accepts the following options. Also see *Note Common options::. `-A RADIX' `--address-radix=RADIX' Select the base in which file offsets are printed. RADIX can be one of the following: `d' decimal; `o' octal; `x' hexadecimal; `n' none (do not print offsets). The default is octal. `-j BYTES' `--skip-bytes=BYTES' Skip BYTES input bytes before formatting and writing. If BYTES begins with `0x' or `0X', it is interpreted in hexadecimal; otherwise, if it begins with `0', in octal; otherwise, in decimal. Appending `b' multiplies BYTES by 512, `k' by 1024, and `m' by 1048576. `-N BYTES' `--read-bytes=BYTES' Output at most BYTES bytes of the input. Prefixes and suffixes on `bytes' are interpreted as for the `-j' option. `-s [N]' `--strings[=N]' Instead of the normal output, output only "string constants": at least N (3 by default) consecutive ASCII graphic characters, followed by a null (zero) byte. `-t TYPE' `--format=TYPE' Select the format in which to output the file data. TYPE is a string of one or more of the below type indicator characters. If you include more than one type indicator character in a single TYPE string, or use this option more than once, `od' writes one copy of each output line using each of the data types that you specified, in the order that you specified. `a' named character, `c' ASCII character or backslash escape, `d' signed decimal, `f' floating point, `o' octal, `u' unsigned decimal, `x' hexadecimal. The type `a' outputs things like `sp' for space, `nl' for newline, and `nul' for a null (zero) byte. Type `c' outputs ` ', `\n', and `\0', respectively. Except for types `a' and `c', you can specify the number of bytes to use in interpreting each number in the given data type by following the type indicator character with a decimal integer. Alternately, you can specify the size of one of the C compiler's built-in data types by following the type indicator character with one of the following characters. For integers (`d', `o', `u', `x'): `C' char, `S' short, `I' int, `L' long. For floating point (`f'): F float, D double, L long double. `-v' `--output-duplicates' Output consecutive lines that are identical. By default, when two or more consecutive output lines would be identical, `od' outputs only the first line, and puts just an asterisk on the following line to indicate the elision. `-w [N]' `--width[=N]' Dump `n' input bytes per output line. This must be a multiple of the least common multiple of the sizes associated with the specified output types. If N is omitted, the default is 32. If this option is not given at all, the default is 16. The next several options map the old, pre-POSIX format specification options to the corresponding POSIX format specs. GNU `od' accepts any combination of old- and new-style options. Format specification options accumulate. `-a' Output as named characters. Equivalent to `-ta'. `-b' Output as octal bytes. Equivalent to `-toC'. `-c' Output as ASCII characters or backslash escapes. Equivalent to `-tc'. `-d' Output as unsigned decimal shorts. Equivalent to `-tu2'. `-f' Output as floats. Equivalent to `-tfF'. `-h' Output as hexadecimal shorts. Equivalent to `-tx2'. `-i' Output as decimal shorts. Equivalent to `-td2'. `-l' Output as decimal longs. Equivalent to `-td4'. `-o' Output as octal shorts. Equivalent to `-to2'. `-x' Output as hexadecimal shorts. Equivalent to `-tx2'. `-C' `--traditional' Recognize the pre-POSIX non-option arguments that traditional `od' accepted. The following syntax: od --traditional [FILE] [[+]OFFSET[.][b] [[+]LABEL[.][b]]] can be used to specify at most one file and optional arguments specifying an offset and a pseudo-start address, LABEL. By default, OFFSET is interpreted as an octal number specifying how many input bytes to skip before formatting and writing. The optional trailing decimal point forces the interpretation of OFFSET as a decimal number. If no decimal is specified and the offset begins with `0x' or `0X' it is interpreted as a hexadecimal number. If there is a trailing `b', the number of bytes skipped will be OFFSET multiplied by 512. The LABEL argument is interpreted just like OFFSET, but it specifies an initial pseudo-address. The pseudo-addresses are displayed in parentheses following any normal address.  File: textutils.info, Node: Formatting file contents, Next: Output of parts of files, Prev: Output of entire files, Up: Top Formatting file contents ************************ These commands reformat the contents of files. * Menu: * fmt invocation:: Reformat paragraph text. * pr invocation:: Paginate or columnate files for printing. * fold invocation:: Wrap input lines to fit in specified width.  File: textutils.info, Node: fmt invocation, Next: pr invocation, Up: Formatting file contents `fmt': Reformat paragraph text ============================== `fmt' fills and joins lines to produce output lines of (at most) a given number of characters (75 by default). Synopsis: fmt [OPTION]... [FILE]... `fmt' reads from the specified FILE arguments (or standard input if none are given), and writes to standard output. By default, blank lines, spaces between words, and indentation are preserved in the output; successive input lines with different indentation are not joined; tabs are expanded on input and introduced on output. `fmt' prefers breaking lines at the end of a sentence, and tries to avoid line breaks after the first word of a sentence or before the last word of a sentence. A "sentence break" is defined as either the end of a paragraph or a word ending in any of `.?!', followed by two spaces or end of line, ignoring any intervening parentheses or quotes. Like TeX, `fmt' reads entire "paragraphs" before choosing line breaks; the algorithm is a variant of that in "Breaking Paragraphs Into Lines" (Donald E. Knuth and Michael F. Plass, `Software--Practice and Experience', 11 (1981), 1119-1184). The program accepts the following options. Also see *Note Common options::. `-c' `--crown-margin' "Crown margin" mode: preserve the indentation of the first two lines within a paragraph, and align the left margin of each subsequent line with that of the second line. `-t' `--tagged-paragraph' "Tagged paragraph" mode: like crown margin mode, except that if indentation of the first line of a paragraph is the same as the indentation of the second, the first line is treated as a one-line paragraph. `-s' `--split-only' Split lines only. Do not join short lines to form longer ones. This prevents sample lines of code, and other such "formatted" text from being unduly combined. `-u' `--uniform-spacing' Uniform spacing. Reduce spacing between words to one space, and spacing between sentences to two spaces. `-WIDTH' `-w WIDTH' `--width=WIDTH' Fill output lines up to WIDTH characters (default 75). `fmt' initially tries to make lines about 7% shorter than this, to give it room to balance line lengths. `-p PREFIX' `--prefix=PREFIX' Only lines beginning with PREFIX (possibly preceded by whitespace) are subject to formatting. The prefix and any preceding whitespace is stripped for the formatting and then re-attached to each formatted output line. One use is to format certain kinds of program comments, while leaving the code unchanged.  File: textutils.info, Node: pr invocation, Next: fold invocation, Prev: fmt invocation, Up: Formatting file contents `pr': Paginate or columnate files for printing ============================================== `pr' writes each FILE (`-' means standard input), or standard input if none are given, to standard output, paginating and optionally outputting in multicolumn format. Synopsis: pr [OPTION]... [FILE]... By default, a 5-line header is printed: two blank lines; a line with the date, the file name, and the page count; and two more blank lines. A five line footer (entirely) is also printed. Form feeds in the input cause page breaks in the output. The program accepts the following options. Also see *Note Common options::. `+PAGE' Begin printing with page PAGE. `-COLUMN' Produce COLUMN-column output and print columns down. The column width is automatically decreased as COLUMN increases; unless you use the `-w' option to increase the page width as well, this option might well cause some input to be truncated. `-a' Print columns across rather than down. `-b' Balance columns on the last page. `-c' Print control characters using hat notation (e.g., `^G'); print other unprintable characters in octal backslash notation. By default, unprintable characters are not changed. `-d' Double space the output. `-e[IN-TABCHAR[IN-TABWIDTH]]' Expand tabs to spaces on input. Optional argument IN-TABCHAR is the input tab character (default is TAB). Second optional argument IN-TABWIDTH is the input tab character's width (default is 8). `-f' `-F' Use a formfeed instead of newlines to separate output pages. `-h HEADER' Replace the file name in the header with the string HEADER. `-i[OUT-TABCHAR[OUT-TABWIDTH]]' Replace spaces with tabs on output. Optional argument OUT-TABCHAR is the output tab character (default is TAB). Second optional argument OUT-TABWIDTH is the output tab character's width (default is 8). `-l N' Set the page length to N (default 66) lines. If N is less than 10, the headers and footers are omitted, as if the `-t' option had been given. `-m' Print all files in parallel, one in each column. `-n[NUMBER-SEPARATOR[DIGITS]]' Precede each column with a line number; with parallel files (`-m'), precede each line with a line number. Optional argument NUMBER-SEPARATOR is the character to print after each number (default is TAB). Optional argument DIGITS is the number of digits per line number (default is 5). `-o N' Indent each line with N (default is zero) spaces wide, i.e., set the left margin. The total page width is `n' plus the width set with the `-w' option. `-r' Do not print a warning message when an argument FILE cannot be opened. (The exit status will still be nonzero, however.) `-s[C]' Separate columns by the single character C. If C is omitted, the default is space; if this option is omitted altogether, the default is TAB. `-t' Do not print the usual 5-line header and the 5-line footer on each page, and do not fill out the bottoms of pages (with blank lines or formfeeds). `-v' Print unprintable characters in octal backslash notation. `-w N' Set the page width to N (default is 72) columns.  File: textutils.info, Node: fold invocation, Prev: pr invocation, Up: Formatting file contents `fold': Wrap input lines to fit in specified width ================================================== `fold' writes each FILE (`-' means standard input), or standard input if none are given, to standard output, breaking long lines. Synopsis: fold [OPTION]... [FILE]... By default, `fold' breaks lines wider than 80 columns. The output is split into as many lines as necessary. `fold' counts screen columns by default; thus, a tab may count more than one column, backspace decreases the column count, and carriage return sets the column to zero. The program accepts the following options. Also see *Note Common options::. `-b' `--bytes' Count bytes rather than columns, so that tabs, backspaces, and carriage returns are each counted as taking up one column, just like other characters. `-s' `--spaces' Break at word boundaries: the line is broken after the last blank before the maximum line length. If the line contains no such blanks, the line is broken at the maximum line length as usual. `-w WIDTH' `--width=WIDTH' Use a maximum line length of WIDTH columns instead of 80.  File: textutils.info, Node: Output of parts of files, Next: Summarizing files, Prev: Formatting file contents, Up: Top Output of parts of files ************************ These commands output pieces of the input. * Menu: * head invocation:: Output the first part of files. * tail invocation:: Output the last part of files. * split invocation:: Split a file into fixed-size pieces. * csplit invocation:: Split a file into context-determined pieces.  File: textutils.info, Node: head invocation, Next: tail invocation, Up: Output of parts of files `head': Output the first part of files ====================================== `head' prints the first part (10 lines by default) of each FILE; it reads from standard input if no files are given or when given a FILE of `-'. Synopses: head [OPTION]... [FILE]... head -NUMBER [OPTION]... [FILE]... If more than one FILE is specicified, `head' prints a one-line header consisting of ==> FILE NAME <== before the output for each FILE. `head' accepts two option formats: the new one, in which numbers are arguments to the options (`-q -n 1'), and the old one, in which the number precedes any option letters (`-1q'). The program accepts the following options. Also see *Note Common options::. `-COUNTOPTIONS' This option is only recognized if it is specified first. COUNT is a decimal number optionally followed by a size letter (`b', `k', `m') as in `-c', or `l' to mean count by lines, or other option letters (`cqv'). `-c BYTES' `--bytes=BYTES' Print the first BYTES bytes, instead of initial lines. Appending `b' multiplies BYTES by 512, `k' by 1024, and `m' by 1048576. `-n N' `--lines=N' Output the first N lines. `-q' `--quiet' `--silent' Never print file name headers. `-v' `--verbose' Always print file name headers.  File: textutils.info, Node: tail invocation, Next: split invocation, Prev: head invocation, Up: Output of parts of files `tail': Output the last part of files ===================================== `tail' prints the last part (10 lines by default) of each FILE; it reads from standard input if no files are given or when given a FILE of `-'. Synopses: tail [OPTION]... [FILE]... tail -NUMBER [OPTION]... [FILE]... tail +NUMBER [OPTION]... [FILE]... If more than one FILE is specified, `tail' prints a one-line header consisting of ==> FILE NAME <== before the output for each FILE. GNU `tail' can output any amount of data (some other versions of `tail' cannot). It also has no `-r' option (print in reverse), since reversing a file is really a different job from printing the end of a file; BSD `tail' (which is the one with `-r') can only reverse files that are at most as large as its buffer, which is typically 32k. A more reliable and versatile way to reverse files is the GNU `tac' command. `tail' accepts two option formats: the new one, in which numbers are arguments to the options (`-n 1'), and the old one, in which the number precedes any option letters (`-1' or `+1'). If any option-argument is a number N starting with a `+', `tail' begins printing with the Nth item from the start of each file, instead of from the end. The program accepts the following options. Also see *Note Common options::. `-COUNT' `+COUNT' This option is only recognized if it is specified first. COUNT is a decimal number optionally followed by a size letter (`b', `k', `m') as in `-c', or `l' to mean count by lines, or other option letters (`cfqv'). `-c BYTES' `--bytes=BYTES' Output the last BYTES bytes, instead of final lines. Appending `b' multiplies BYTES by 512, `k' by 1024, and `m' by 1048576. `-f' `--follow' Loop forever trying to read more characters at the end of the file, presumably because the file is growing. Ignored if reading from a pipe. If more than one file is given, `tail' prints a header whenever it gets output from a different file, to indicate which file that output is from. `-n N' `--lines=N' Output the last N lines. `-q' `-quiet' `--silent' Never print file name headers. `-v' `--verbose' Always print file name headers.  File: textutils.info, Node: split invocation, Next: csplit invocation, Prev: tail invocation, Up: Output of parts of files `split': Split a file into fixed-size pieces ============================================ `split' creates output files containing consecutive sections of INPUT (standard input if none is given or INPUT is `-'). Synopsis: split [OPTION] [INPUT [PREFIX]] By default, `split' puts 1000 lines of INPUT (or whatever is left over for the last section), into each output file. The output files' names consist of PREFIX (`x' by default) followed by a group of letters `aa', `ab', and so on, such that concatenating the output files in sorted order by file name produces the original input file. (If more than 676 output files are required, `split' uses `zaa', `zab', etc.) The program accepts the following options. Also see *Note Common options::. `-LINES' `-l LINES' `--lines=LINES' Put LINES lines of INPUT into each output file. `-b BYTES' `--bytes=BYTES' Put the first BYTES bytes of INPUT into each output file. Appending `b' multiplies BYTES by 512, `k' by 1024, and `m' by 1048576. `-C BYTES' `--line-bytes=BYTES' Put into each output file as many complete lines of INPUT as possible without exceeding BYTES bytes. For lines longer than BYTES bytes, put BYTES bytes into each output file until less than BYTES bytes of the line are left, then continue normally. BYTES has the same format as for the `--bytes' option.  File: textutils.info, Node: csplit invocation, Prev: split invocation, Up: Output of parts of files `csplit': Split a file into context-determined pieces ===================================================== `csplit' creates zero or more output files containing sections of INPUT (standard input if INPUT is `-'). Synopsis: csplit [OPTION]... INPUT PATTERN... The contents of the output files are determined by the PATTERN arguments, as detailed below. An error occurs if a PATTERN argument refers to a nonexistent line of the input file (e.g., if no remaining line matches a given regular expression). After every PATTERN has been matched, any remaining input is copied into one last output file. By default, `csplit' prints the number of bytes written to each output file after it has been created. The types of pattern arguments are: `N' Create an output file containing the input up to but not including line N (a positive integer). If followed by a repeat count, also create an output file containing the next LINE lines of the input file once for each repeat. `/REGEXP/[OFFSET]' Create an output file containing the current line up to (but not including) the next line of the input file that contains a match for REGEXP. The optional OFFSET is a `+' or `-' followed by a positive integer. If it is given, the input up to the matching line plus or minus OFFSET is put into the output file, and the line after that begins the next section of input. `%REGEXP%[OFFSET]' Like the previous type, except that it does not create an output file, so that section of the input file is effectively ignored. `{REPEAT-COUNT}' Repeat the previous pattern REPEAT-COUNT additional times. REPEAT-COUNT can either be a positive integer or an asterisk, meaning repeat as many times as necessary until the input is exausted. The output files' names consist of a prefix (`xx' by default) followed by a suffix. By default, the suffix is an ascending sequence of two-digit decimal numbers from `00' and up to `99'. In any case, concatenating the output files in sorted order by filename produces the original input file. By default, if `csplit' encounters an error or receives a hangup, interrupt, quit, or terminate signal, it removes any output files that it has created so far before it exits. The program accepts the following options. Also see *Note Common options::. `-f PREFIX' `--prefix=PREFIX' Use PREFIX as the output file name prefix. `-b SUFFIX' `--suffix=SUFFIX' Use SUFFIX as the output file name suffix. When this option is specified, the suffix string must include exactly one `printf(3)'-style conversion specification, possibly including format specification flags, a field width, a precision specifications, or all of these kinds of modifiers. The format letter must convert a binary integer argument to readable form; thus, only `d', `i', `u', `o', `x', and `X' conversions are allowed. The entire SUFFIX is given (with the current output file number) to `sprintf(3)' to form the file name suffixes for each of the individual output files in turn. If this option is used, the `--digits' option is ignored. `-n DIGITS' `--digits=DIGITS' Use output file names containing numbers that are DIGITS digits long instead of the default 2. `-k' `--keep-files' Do not remove output files when errors are encountered. `-z' `--elide-empty-files' Suppress the generation of zero-length output files. (In cases where the section delimiters of the input file are supposed to mark the first lines of each of the sections, the first output file will generally be a zero-length file unless you use this option.) The output file sequence numbers always run consecutively starting from 0, even when this option is specified. `-s' `-q' `--silent' `--quiet' Do not print counts of output file sizes.  File: textutils.info, Node: Summarizing files, Next: Operating on sorted files, Prev: Output of parts of files, Up: Top Summarizing files ***************** These commands generate just a few numbers representing entire contents of files. * Menu: * wc invocation:: Print byte, word, and line counts. * sum invocation:: Print checksum and block counts. * cksum invocation:: Print CRC checksum and byte counts. * md5sum invocation:: Print or check message-digests.  File: textutils.info, Node: wc invocation, Next: sum invocation, Up: Summarizing files `wc': Print byte, word, and line counts ======================================= `wc' counts the number of bytes, whitespace-separated words, and newlines in each given FILE, or standard input if none are given or for a FILE of `-'. Synopsis: wc [OPTION]... [FILE]... `wc' prints one line of counts for each file, and if the file was given as an argument, it prints the file name following the counts. If more than one FILE is given, `wc' prints a final line containing the cumulative counts, with the file name `total'. The counts are printed in this order: newlines, words, bytes. By default, `wc' prints all three counts. Options can specify that only certain counts be printed. Options do not undo others previously given, so wc --bytes --words prints both the byte counts and the word counts. The program accepts the following options. Also see *Note Common options::. `-c' `--bytes' `--chars' Print only the byte counts. `-w' `--words' Print only the word counts. `-l' `--lines' Print only the newline counts.  File: textutils.info, Node: sum invocation, Next: cksum invocation, Prev: wc invocation, Up: Summarizing files `sum': Print checksum and block counts ====================================== `sum' computes a 16-bit checksum for each given FILE, or standard input if none are given or for a FILE of `-'. Synopsis: sum [OPTION]... [FILE]... `sum' prints the checksum for each FILE followed by the number of blocks in the file (rounded up). If more than one FILE is given, file names are also printed (by default). (With the `--sysv' option, corresponding file name are printed when there is at least one file argument.) By default, GNU `sum' computes checksums using an algorithm compatible with BSD `sum' and prints file sizes in units of 1024-byte blocks. The program accepts the following options. Also see *Note Common options::. `-r' Use the default (BSD compatible) algorithm. This option is included for compatibility with the System V `sum'. Unless `-s' was also given, it has no effect. `-s' `--sysv' Compute checksums using an algorithm compatible with System V `sum''s default, and print file sizes in units of 512-byte blocks. `sum' is provided for compatibility; the `cksum' program (see next section) is preferable in new applications.  File: textutils.info, Node: cksum invocation, Next: md5sum invocation, Prev: sum invocation, Up: Summarizing files `cksum': Print CRC checksum and byte counts =========================================== `cksum' computes a cyclic redundancy check (CRC) checksum for each given FILE, or standard input if none are given or for a FILE of `-'. Synopsis: cksum [OPTION]... [FILE]... `cksum' prints the CRC checksum for each file along with the number of bytes in the file, and the filename unless no arguments were given. `cksum' is typically used to ensure that files have been transferred by unreliable means (e.g., netnews) have not been corrupted, by comparing the `cksum' output for the received files with the `cksum' output for the original files (typically given in the distribution). The CRC algorithm is specified by the POSIX.2 standard. It is not compatible with the BSD or System V `sum' algorithms (see the previous section); it is more robust. The only options are `--help' and `--version'. *Note Common options::.  File: textutils.info, Node: md5sum invocation, Prev: cksum invocation, Up: Summarizing files `md5sum': Print or check message-digests ======================================== `md5sum' computes a 128-bit checksum (or "fingerprint" or "message-digest" for each given FILE, or standard input if none are given or for a FILE of `-'. It can also check if the checksum has changed. Synopsis: md5sum [OPTION]... [FILE]... For each FILE, `md5sum' outputs the MD5 checksum, a flag indicating a binary or text input file, and the filename. The program accepts the following options. Also see *Note Common options::. `-b' `--binary' Treat input files as binary. This makes no difference on Unix systems, but other systems have different internal and external character representations, notably to mark end-of-line. `-c' `--check=FILE' FILE is taken as the output of a former run of `md5sum': each line consists of an MD5 checksum, a binary/text flag, and a filename. The file will be opened (with each possible relative path) and the its message-digest computed. If this computed message digest is not the same as that given in the line, the file will be marked as failed. `-s' `--string=STRING' Compute the message digest for STRING, instead of for a file. The result is the same as for a file with contains exactly STRING. `-t' `--text' Treat all input files as text files. This is the reverse of `--binary'. `-v' `--verbose' Print progress information.  File: textutils.info, Node: Operating on sorted files, Next: Operating on fields within a line, Prev: Summarizing files, Up: Top Operating on sorted files ************************* These commands work with (or produce) sorted files. * Menu: * sort invocation:: Sort text files. * uniq invocation:: Uniqify files. * comm invocation:: Compare two sorted files line by line.  File: textutils.info, Node: sort invocation, Next: uniq invocation, Up: Operating on sorted files `sort': Sort text files ======================= `sort' sorts, merges, or compares all the lines from the given files, or standard input if none are given or for a FILE of `-'. By default, `sort' writes the results to standard output. Synopsis: sort [OPTION]... [FILE]... `sort' has three modes of operation: sort (the default), merge, and check for sortedness. The following options change the operation mode: `-c' Check whether the given files are already sorted: if they are not all sorted, print an error message and exit with a status of 1. `-m' Merge the given files by sorting them as a group. Each input file must always be individually sorted. It always works to sort instead of merge; merging is provided because it is faster, in the case where it works. A pair of lines is compared as follows: if any key fields have been specified, `sort' compares each pair of fields, in the order specified on the command line, according to the associated ordering options, until a difference is found or no fields are left. If any of the global options `Mbdfinr' are given but no key fields are specified, `sort' compares the entire lines according to the global options. Finally, as a last resort when all keys compare equal (or if no ordering options were specified at all), `sort' compares the lines byte by byte in machine collating sequence. The last resort comparison honors the `-r' global option. The `-s' (stable) option disables this last-resort comparison so that lines in which all fields compare equal are left in their original relative order. If no fields or global options are specified, `-s' has no effect. GNU `sort' (as specified for all GNU utilities) has no limits on input line length or restrictions on bytes allowed within lines. In addition, if the final byte of an input file is not a newline, GNU `sort' silently supplies one. If the environment variable `TMPDIR' is set, `sort' uses its value as the directory for temporary files instead of `/tmp'. The `-T TEMPDIR' option in turn overrides the environment variable. The following options affect the ordering of output lines. They may be specified globally or as part of a specific key field. If no key fields are specified, global options apply to comparison of entire lines; otherwise the global options are inherited by key fields that do not specify any special options of their own. `-b' Ignore leading blanks when finding sort keys in each line. `-d' Sort in "phone directory" order: ignore all characters except letters, digits and blanks when sorting. `-f' Fold lowercase characters into the equivalent uppercase characters when sorting so that, for example, `b' and `B' sort as equal. `-i' Ignore characters outside the printable ASCII range 040-0176 octal (inclusive) when sorting. `-M' An initial string, consisting of any amount of whitespace, followed by three letters abbreviating a month name, is folded to UPPER case and compared in the order `JAN' < `FEB' < ... < `DEC'. Invalid names compare low to valid names. `-n' Sort numerically: the number begins each line; specifically, it consists of optional whitespace, an optional `-' sign, and zero or more digits, optionally followed by a decimal point and zero or more digits. `-r' Reverse the result of comparison, so that lines with greater key values appear earlier in the output instead of later. Other options are: `-o OUTPUT-FILE' Write output to OUTPUT-FILE instead of standard output. If OUTPUT-FILE is one of the input files, `sort' copies it to a temporary file before sorting and writing the output to OUTPUT-FILE. `-t SEPARATOR' Use character SEPARATOR as the field separator when finding the sort keys in each line. By default, fields are separated by the empty string between a non-whitespace character and a whitespace character. That is, given the input line ` foo bar', `sort' breaks it into fields ` foo' and ` bar'. The field separator is not considered to be part of either the field preceding or the field following. `-u' For the default case or the `-m' option, only output the first of a sequence of lines that compare equal. For the `-c' option, check that no pair of consecutive lines compares equal. `-k POS1[,POS2]' The recommended, POSIX, option for specifying a sort field. The field consists of the line between POS1 and POS2 (or the end of the line, if POS2 is omitted), inclusive. Fields and character positions are numbered starting with 1. See below. `+POS1[-POS2]' The obsolete, traditional option for specifying a sort field. The field consists of the line between POS1 and up to but not including POS2 (or the end of the line if POS2 is omitted). Fields and character positions are numbered starting with 0. See below. In addition, when GNU `sort' is invoked with exactly one argument, options `--help' and `--version' are recognized. *Note Common options::. Historical (BSD and System V) implementations of `sort' have differed in their interpretation of some options, particularly `-b', `-f', and `-n'. GNU sort follows the POSIX behavior, which is usually (but not always!) like the System V behavior. According to POSIX, `-n' no longer implies `-b'. For consistency, `-M' has been changed in the same way. This may affect the meaning of character positions in field specifications in obscure cases. The only fix is to add an explicit `-b'. A position in a sort field specified with the `-k' or `+' option has the form `F.C', where F is the number of the field to use and C is the number of the first character from the beginning of the field (for `+POS') or from the end of the previous field (for `-POS'). If the `.C' is omitted, it's taken to be the first character in the field. If the `-b' option was specified, the `.C' part of a field specification is counted from the first nonblank character of the field (for `+POS') or from the first nonblank character following the previous field (for `-POS'). A sort key option may also have any of the option letters `Mbdfinr' appended to it, in which case the global ordering options are not used for that particular field. The `-b' option may be independently attached to either or both of the `+POS' and `-POS' parts of a field specification, and if it is inherited from the global options it will be attached to both. If a `-n' or `-M' option is used, thus implying a `-b' option, the `-b' option is taken to apply to both the `+POS' and the `-POS' parts of a key specification. Keys may span multiple fields.  File: textutils.info, Node: uniq invocation, Next: comm invocation, Prev: sort invocation, Up: Operating on sorted files `uniq': Uniqify files ===================== `uniq' writes the unique lines in the given `input', or standard input if nothing is given or for an INPUT name of `-'. Synopsis: uniq [OPTION]... [INPUT [OUTPUT]] By default, `uniq' prints the unique lines in a sorted file, i.e., discards all but one of identical successive lines. Optionally, it can instead show only lines that appear exactly once, or lines that appear more than once. The input must be sorted. If your input is not sorted, perhaps you want to use `sort -u'. If no OUTPUT file is specified, `uniq' writes to standard output. The program accepts the following options. Also see *Note Common options::. `-N' `-f N' `--skip-fields=N' Skip N fields on each line before checking for uniqueness. Fields are sequences of non-space non-tab characters that are separated from each other by at least one spaces or tabs. `+N' `-s N' `--skip-chars=N' Skip N characters before checking for uniqueness. If you use both the field and character skipping options, fields are skipped over first. `-c' `--count' Print the number of times each line occurred along with the line. `-d' `--repeated' Print only duplicate lines. `-u' `--unique' Print only unique lines. `-w N' `--check-chars=N' Compare N characters on each line (after skipping any specified fields and characters). By default the entire rest of the lines are compared.  File: textutils.info, Node: comm invocation, Prev: uniq invocation, Up: Operating on sorted files `comm': Compare two sorted files line by line ============================================= `comm' writes to standard output lines that are common, and lines that are unique, to two input files; a file name of `-' means standard input. Synopsis: comm [OPTION]... FILE1 FILE2 The input files must be sorted before `comm' can be used. With no options, `comm' produces three column output. Column one contains lines unique to FILE1, column two contains lines unique to FILE2, and column three contains lines common to both files. The options `-1', `-2', and `-3' suppress printing of the corresponding columns. Also see *Note Common options::.  File: textutils.info, Node: Operating on fields within a line, Next: Operating on characters, Prev: Operating on sorted files, Up: Top Operating on fields within a line ********************************* * Menu: * cut invocation:: Print selected parts of lines. * paste invocation:: Merge lines of files. * join invocation:: Join lines on a common field.  File: textutils.info, Node: cut invocation, Next: paste invocation, Up: Operating on fields within a line `cut': Print selected parts of lines ==================================== `cut' writes to standard output selected parts of each line of each input file, or standard input if no files are given or for a file name of `-'. Synopsis: cut [OPTION]... [FILE]... In the table which follows, the BYTE-LIST, CHARACTER-LIST, and FIELD-LIST are one or more numbers or ranges (two numbers separated by a dash) separated by commas. Bytes, characters, and fields are numbered from starting at 1. Incomplete ranges may be given: `-M' means `1-M'; `N-' means `N' through end of line or last field. The program accepts the following options. Also see *Note Common options::. `-b BYTE-LIST' `--bytes=BYTE-LIST' Print only the bytes in positions listed in BYTE-LIST. Tabs and backspaces are treated like any other character; they take up 1 byte. `-c CHARACTER-LIST' `--characters=CHARACTER-LIST' Print only characters in positions listed in CHARACTER-LIST. The same as `-b' for now, but internationalization will change that. Tabs and backspaces are treated like any other character; they take up 1 character. `-f FIELD-LIST' `--fields=FIELD-LIST' Print only the fields listed in FIELD-LIST. Fields are separated by a TAB by default. `-d DELIM' `--delimiter=DELIM' For `-f', fields are separated by the first character in DELIM (default is TAB). `-n' Do not split multibyte characters (no-op for now). `-s' `--only-delimited' For `-f', do not print lines that do not contain the field separator character.  File: textutils.info, Node: paste invocation, Next: join invocation, Prev: cut invocation, Up: Operating on fields within a line `paste': Merge lines of files ============================= `paste' writes to standard output lines consisting of sequentially corresponding lines of each given file, separated by TAB. Standard input is used for a file name of `-' or if no input files are given. Synopsis: paste [OPTION]... [FILE]... The program accepts the following options. Also see *Note Common options::. `-s' `--serial' Paste the lines of one file at a time rather than one line from each file. `-d DELIM-LIST' `--delimiters DELIM-LIST' Consecutively use the characters in DELIM-LIST instead of TAB to separate merged lines. When DELIM-LIST is exhausted, start again at its beginning.  File: textutils.info, Node: join invocation, Prev: paste invocation, Up: Operating on fields within a line `join': Join lines on a common field ==================================== `join' writes to standard output a line for each pair of input lines that have identical join fields. Synopsis: join [OPTION]... FILE1 FILE2 Either FILE1 or FILE2 (but not both) can be `-', meaning standard input. FILE1 and FILE2 should be already sorted in increasing order (not numerically) on the join fields; unless the `-t' option is given, they should be sorted ignoring blanks at the start of the line, as in `sort -b'. The defaults are: the join field is the first field in each line; fields in the input are separated by one or more blanks, with leading blanks on the line ignored; fields in the output are separated by a space; each output line consists of the join field, the remaining fields from FILE1, then the remaining fields from FILE2. The program accepts the following options. Also see *Note Common options::. `-a FILE-NUMBER' Print a line for each unpairable line in file FILE-NUMBER (either `1' or `2'), in addition to the normal output. `-e STRING' Replace those output fields that are missing in the input with STRING. `-1 FIELD' `-j1 FIELD' Join on field FIELD (a positive integer) of file 1. `-2 FIELD' `-j2 FIELD' Join on field FIELD (a positive integer) of file 2. `-j FIELD' Equivalent to `-1 FIELD -2 FIELD'. `-o FIELD-LIST...' Construct each output line according to the format in FIELD-LIST. Each element in FIELD-LIST consists of a file number (either 1 or 2), a period, and a field number (a positive integer). The elements in the list are separated by commas or blanks. Multiple FIELD-LIST arguments can be given after a single `-o' option; the values of all lists given with `-o' are concatenated together. `-t CHAR' Use character CHAR as the input and output field separator. `-v FILE-NUMBER' Print a line for each unpairable line in file FILE-NUMBER (either 1 or 2), instead of the normal output. In addition, when GNU `join' is invoked with exactly one argument, options `--help' and `--version' are recognized. *Note Common options::.  File: textutils.info, Node: Operating on characters, Next: Opening the software toolbox, Prev: Operating on fields within a line, Up: Top Operating on characters *********************** This commands operate on individual characters. * Menu: * tr invocation:: Translate, squeeze, and/or delete characters. * expand invocation:: Convert tabs to spaces. * unexpand invocation:: Convert spaces to tabs.  File: textutils.info, Node: tr invocation, Next: expand invocation, Up: Operating on characters `tr': Translate, squeeze, and/or delete characters ================================================== Synopsis: tr [OPTION]... SET1 [SET2] `tr' copies standard input to standard output, performing one of the following operations: * translate, and optionally squeeze repeated characters in the result, * squeeze repeated characters, * delete characters, * delete characters, then squeeze repeated characters from the result. The SET1 and (if given) SET2 arguments define ordered sets of characters, referred to below as SET1 and SET2. These sets are the characters of the input that `tr' operates on. The `--complement' (`-c') option replaces SET1 with its complement (all of the characters that are not in SET1). * Menu: * Character sets:: Specifying sets of characters. * Translating:: Changing one characters to another. * Squeezing:: Squeezing repeats and deleting. * Warnings in tr:: Warning messages.  File: textutils.info, Node: Character sets, Next: Translating, Up: tr invocation Specifying sets of characters ----------------------------- The format of the SET1 and SET2 arguments resembles the format of regular expressions; however, they are not regular expressions, only lists of characters. Most characters simply represent themselves in these strings, but the strings can contain the shorthands listed below, for convenience. Some of them can be used only in SET1 or SET2, as noted below. Backslash escapes. A backslash followed by a character not listed below causes an error message. `\a' Control-G, `\b' Control-H, `\f' Control-L, `\n' Control-J, `\r' Control-M, `\t' Control-I, `\v' Control-K, `\OOO' The character with the value given by OOO, which is 1 to 3 octal digits, `\\' A backslash. Ranges. The notation `M-N' expands to all of the characters from M through N, in ascending order. M should collate before N; if it doesn't, an error results. As an example, `0-9' is the same as `0123456789'. Although GNU `tr' does not support the System V syntax that uses square brackets to enclose ranges, translations specified in that format will still work as long as the brackets in STRING1 correspond to identical brackets in STRING2. Repeated characters. The notation `[C*N]' in SET2 expands to N copies of character C. Thus, `[y*6]' is the same as `yyyyyy'. The notation `[C*]' in STRING2 expands to as many copies of C as are needed to make SET2 as long as SET1. If N begins with `0', it is interpreted in octal, otherwise in decimal. Character classes. The notation `[:CLASS:]' expands to all of the characters in the (predefined) class CLASS. The characters expand in no particular order, except for the `upper' and `lower' classes, which expand in ascending order. When the `--delete' (`-d') and `--squeeze-repeats' (`-s') options are both given, any character class can be used in SET2. Otherwise, only the character classes `lower' and `upper' are accepted in SET2, and then only if the corresponding character class (`upper' and `lower', respectively) is specified in the same relative position in SET1. Doing this specifies case conversion. The class names are given below; an error results when an invalid class name is given. `alnum' Letters and digits. `alpha' Letters. `blank' Horizontal whitespace. `cntrl' Control characters. `digit' Digits. `graph' Printable characters, not including space. `lower' Lowercase letters. `print' Printable characters, including space. `punct' Punctuation characters. `space' Horizontal or vertical whitespace. `upper' Uppercase letters. `xdigit' Hexadecimal digits. Equivalence classes. The syntax `[=C=]' expands to all of the characters that are equivalent to C, in no particular order. Equivalence classes are a relatively recent invention intended to support non-English alphabets. But there seems to be no standard way to define them or determine their contents. Therefore, they are not fully implemented in GNU `tr'; each character's equivalence class consists only of that character, which is of no particular use.  File: textutils.info, Node: Translating, Next: Squeezing, Prev: Character sets, Up: tr invocation Translating ----------- `tr' performs translation when SET1 and SET2 are both given and the `--delete' (`-d') option is not given. `tr' translates each character of its input that is in SET1 to the corresponding character in SET2. Characters not in SET1 are passed through unchanged. When a character appears more than once in SET1 and the corresponding characters in SET2 are not all the same, only the final one is used. For example, these two commands are equivalent: tr aaa xyz tr a z A common use of `tr' is to convert lowercase characters to uppercase. This can be done in many ways. Here are three of them: tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ tr a-z A-Z tr '[:lower:]' '[:upper:]' When `tr' is performing translation, SET1 and SET2 typically have the same length. If SET1 is shorter than SET2, the extra characters at the end of SET2 are ignored. On the other hand, making SET1 longer than SET2 is not portable; POSIX.2 says that the result is undefined. In this situation, BSD `tr' pads SET2 to the length of SET1 by repeating the last character of SET2 as many times as necessary. System V `tr' truncates SET1 to the length of SET2. By default, GNU `tr' handles this case like BSD `tr'. When the `--truncate-set1' (`-t') option is given, GNU `tr' handles this case like the System V `tr' instead. This option is ignored for operations other than translation. Acting like System V `tr' in this case breaks the relatively common BSD idiom: tr -cs A-Za-z0-9 '\012' because it converts only zero bytes (the first element in the complement of SET1), rather than all non-alphanumerics, to newlines.  File: textutils.info, Node: Squeezing, Next: Warnings in tr, Prev: Translating, Up: tr invocation Squeezing repeats and deleting ------------------------------ When given just the `--delete' (`-d') option, `tr' removes any input characters that are in SET1. When given just the `--squeeze-repeats' (`-s') option, `tr' replaces each input sequence of a repeated character that is in SET1 with a single occurrence of that character. When given both `--delete' and `--squeeze-repeats', `tr' first performs any deletions using SET1, then squeezes repeats from any remaining characters using SET2. The `--squeeze-repeats' option may also be used when translating, in which case `tr' first performs translation, then squeezes repeats from any remaining characters using SET2. Here are some examples to illustrate various combinations of options: * Remove all zero bytes: tr -d '\000' * Put all words on lines by themselves. This converts all non-alphanumeric characters to newlines, then squeezes each string of repeated newlines into a single newline: tr -cs '[a-zA-Z0-9]' '[\n*]' * Convert each sequence of repeated newlines to a single newline: tr -s '\n'  File: textutils.info, Node: Warnings in tr, Prev: Squeezing, Up: tr invocation Warning messages ---------------- Setting the environment variable `POSIXLY_CORRECT' turns off the following warning and error messages, for strict compliance with POSIX.2. Otherwise, the following diagnostics are issued: 1. When the `--delete' option is given but `--squeeze-repeats' is not, and SET2 is given, GNU `tr' by default prints a usage message and exits, because SET2 would not be used. The POSIX specification says that SET2 must be ignored in this case. Silently ignoring arguments is a bad idea. 2. When an ambiguous octal escape is given. For example, `\400' is actually `\40' followed by the digit `0', because the value 400 octal does not fit into a single byte. GNU `tr' does not provide complete BSD or System V compatibility. For example, it is impossible to disable interpretation of the POSIX constructs `[:alpha:]', `[=c=]', and `[c*10]'. Also, GNU `tr' does not delete zero bytes automatically, unlike traditional Unix versions, which provide no way to preserve zero bytes.  File: textutils.info, Node: expand invocation, Next: unexpand invocation, Prev: tr invocation, Up: Operating on characters `expand': Convert tabs to spaces ================================ `expand' writes the contents of each given FILE, or standard input if none are given or for a FILE of `-', to standard output, with tab characters converted to the appropriate number of spaces. Synopsis: expand [OPTION]... [FILE]... By default, `expand' converts all tabs to spaces. It preserves backspace characters in the output; they decrement the column count for tab calculations. The default action is equivalent to `-8' (set tabs every 8 columns). The program accepts the following options. Also see *Note Common options::. `-TAB1[,TAB2]...' `-t TAB1[,TAB2]...' `--tabs=TAB1[,TAB2]...' If only one tab stop is given, set the tabs TAB1 spaces apart (default is 8). Otherwise, set the tabs at columns TAB1, TAB2, ... (numbered from 0), and replace any tabs beyond the last tabstop given with single spaces. If the tabstops are specified with the `-t' or `--tabs' option, they can be separated by blanks as well as by commas. `-i' `--initial' Only convert initial tabs (those that precede all non-space or non-tab characters) on each line to spaces.  File: textutils.info, Node: unexpand invocation, Prev: expand invocation, Up: Operating on characters `unexpand': Convert spaces to tabs ================================== `unexpand' writes the contents of each given FILE, or standard input if none are given or for a FILE of `-', to standard output, with strings of two or more space or tab characters converted to as many tabs as possible followed by as many spaces as are needed. Synopsis: unexpand [OPTION]... [FILE]... By default, `unexpand' converts only initial spaces and tabs (those that precede all non space or tab characters) on each line. It preserves backspace characters in the output; they decrement the column count for tab calculations. By default, tabs are set at every 8th column. The program accepts the following options. Also see *Note Common options::. `-TAB1[,TAB2]...' `-t TAB1[,TAB2]...' `--tabs=TAB1[,TAB2]...' If only one tab stop is given, set the tabs TAB1 spaces apart instead of the default 8. Otherwise, set the tabs at columns TAB1, TAB2, ... (numbered from 0), and leave spaces and tabs beyond the tabstops given unchanged. If the tabstops are specified with the `-t' or `--tabs' option, they can be separated by blanks as well as by commas. This option implies the `-a' option. `-a' `--all' Convert all strings of two or more spaces or tabs, not just initial ones, to tabs.  File: textutils.info, Node: Opening the software toolbox, Next: Index, Prev: Operating on characters, Up: Top Opening the software toolbox **************************** This chapter originally appeared in `Linux Journal', volume 1, number 2, in the `What's GNU?' column. It was written by Arnold Robbins. * Menu: * Toolbox introduction:: * I/O redirection:: * The `who' command:: * The `cut' command:: * The `sort' command:: * The `uniq' command:: * Putting the tools together::  File: textutils.info, Node: Toolbox introduction, Next: I/O redirection, Up: Opening the software toolbox Toolbox introduction ==================== This month's column is only peripherally related to the GNU Project, in that it describes a number of the GNU tools on your Linux system and how they might be used. What it's really about is the "Software Tools" philosophy of program development and usage. The software tools philosophy was an important and integral concept in the initial design and development of Unix (of which Linux and GNU are essentially clones). Unfortunately, in the modern day press of Internetworking and flashy GUIs, it seems to have fallen by the wayside. This is a shame, since it provides a powerful mental model for solving many kinds of problems. Many people carry a Swiss Army knife around in their pants pockets (or purse). A Swiss Army knife is a handy tool to have: it has several knife blades, a screwdriver, tweezers, toothpick, nail file, corkscrew, and perhaps a number of other things on it. For the everyday, small miscellaneous jobs where you need a simple, general purpose tool, it's just the thing. On the other hand, an experienced carpenter doesn't build a house using a Swiss Army knife. Instead, he has a toolbox chock full of specialized tools--a saw, a hammer, a screwdriver, a plane, and so on. And he knows exactly when and where to use each tool; you won't catch him hammering nails with the handle of his screwdriver. The Unix developers at Bell Labs were all professional programmers and trained computer scientists. They had found that while a one-size-fits-all program might appeal to a user because there's only one program to use, in practice such programs are a. difficult to write, b. difficult to maintain and debug, and c. difficult to extend to meet new situations. Instead, they felt that programs should be specialized tools. In short, each program "should do one thing well." No more and no less. Such programs are simpler to design, write, and get right--they only do one thing. Furthermore, they found that with the right machinery for hooking programs together, that the whole was greater than the sum of the parts. By combining several special purpose programs, you could accomplish a specific task that none of the programs was designed for, and accomplish it much more quickly and easily than if you had to write a special purpose program. We will see some (classic) examples of this further on in the column. (An important additional point was that, if necessary, take a detour and build any software tools you may need first, if you don't already have something appropriate in the toolbox.)  File: textutils.info, Node: I/O redirection, Next: The `who' command, Prev: Toolbox introduction, Up: Opening the software toolbox I/O redirection =============== Hopefully, you are familiar with the basics of I/O redirection in the shell, in particular the concepts of "standard input," "standard output," and "standard error". Briefly, "standard input" is a data source, where data comes from. A program should not need to either know or care if the data source is a disk file, a keyboard, a magnetic tape, or even a punched card reader. Similarly, "standard output" is a data sink, where data goes to. The program should neither know nor care where this might be. Programs that only read their standard input, do something to the data, and then send it on, are called "filters", by analogy to filters in a water pipeline. With the Unix shell, it's very easy to set up data pipelines: program_to_create_data | filter1 | .... | filterN > final.pretty.data We start out by creating the raw data; each filter applies some successive transformation to the data, until by the time it comes out of the pipeline, it is in the desired form. This is fine and good for standard input and standard output. Where does the standard error come in to play? Well, think about `filter1' in the pipeline above. What happens if it encounters an error in the data it sees? If it writes an error message to standard output, it will just disappear down the pipeline into `filter2''s input, and the user will probably never see it. So programs need a place where they can send error messages so that the user will notice them. This is standard error, and it is usually connected to your console or window, even if you have redirected standard output of your program away from your screen. For filter programs to work together, the format of the data has to be agreed upon. The most straightforward and easiest format to use is simply lines of text. Unix data files are generally just streams of bytes, with lines delimited by the ASCII LF (Line Feed) character, conventionally called a "newline" in the Unix literature. (This is `'\n'' if you're a C programmer.) This is the format used by all the traditional filtering programs. (Many earlier operating systems had elaborate facilities and special purpose programs for managing binary data. Unix has always shied away from such things, under the philosophy that it's easiest to simply be able to view and edit your data with a text editor.) OK, enough introduction. Let's take a look at some of the tools, and then we'll see how to hook them together in interesting ways. In the following discussion, we will only present those command line options that interest us. As you should always do, double check your system documentation for the full story.  File: textutils.info, Node: The `who' command, Next: The `cut' command, Prev: I/O redirection, Up: Opening the software toolbox The `who' command ================= The first program is the `who' command. By itself, it generates a list of the users who are currently logged in. Although I'm writing this on a single-user system, we'll pretend that several people are logged in: $ who arnold console Jan 22 19:57 miriam ttyp0 Jan 23 14:19(:0.0) bill ttyp1 Jan 21 09:32(:0.0) arnold ttyp2 Jan 23 20:48(:0.0) Here, the `$' is the usual shell prompt, at which I typed `who'. There are three people logged in, and I am logged in twice. On traditional Unix systems, user names are never more than eight characters long. This little bit of trivia will be useful later. The output of `who' is nice, but the data is not all that exciting.  File: textutils.info, Node: The `cut' command, Next: The `sort' command, Prev: The `who' command, Up: Opening the software toolbox The `cut' command ================= The next program we'll look at is the `cut' command. This program cuts out columns or fields of input data. For example, we can tell it to print just the login name and full name from the `/etc/passwd file'. The `/etc/passwd' file has seven fields, separated by colons: arnold:xyzzy:2076:10:Arnold D. Robbins:/home/arnold:/bin/ksh To get the first and fifth fields, we would use cut like this: $ cut -d: -f1,5 /etc/passwd root:Operator ... arnold:Arnold D. Robbins miriam:Miriam A. Robbins ... With the `-c' option, `cut' will cut out specific characters (i.e., columns) in the input lines. This command looks like it might be useful for data filtering.  File: textutils.info, Node: The `sort' command, Next: The `uniq' command, Prev: The `cut' command, Up: Opening the software toolbox The `sort' command ================== Next we'll look at the `sort' command. This is one of the most powerful commands on a Unix-style system; one that you will often find yourself using when setting up fancy data plumbing. The `sort' command reads and sorts each file named on the command line. It then merges the sorted data and writes it to standard output. It will read standard input if no files are given on the command line (thus making it into a filter). The sort is based on the machine collating sequence (ASCII) or based on user-supplied ordering criteria.  File: textutils.info, Node: The `uniq' command, Next: Putting the tools together, Prev: The `sort' command, Up: Opening the software toolbox The `uniq' command ================== Finally (at least for now), we'll look at the `uniq' program. When sorting data, you will often end up with duplicate lines, lines that are identical. Usually, all you need is one instance of each line. This is where `uniq' comes in. The `uniq' program reads its standard input, which it expects to be sorted. It only prints out one copy of each duplicated line. It does have several options. Later on, we'll use the `-c' option, which prints each unique line, preceded by a count of the number of times that line occurred in the input.  File: textutils.info, Node: Putting the tools together, Prev: The `uniq' command, Up: Opening the software toolbox Putting the tools together ========================== Now, let's suppose this is a large BBS system with dozens of users logged in. The management wants the SysOp to write a program that will generate a sorted list of logged in users. Furthermore, even if a user is logged in multiple times, his or her name should only show up in the output once. The SysOp could sit down with the system documentation and write a C program that did this. It would take perhaps a couple of hundred lines of code and about two hours to write it, test it, and debug it. However, knowing the software toolbox, the SysOp can instead start out by generating just a list of logged on users: $ who | cut -c1-8 arnold miriam bill arnold Next, sort the list: $ who | cut -c1-8 | sort arnold arnold bill miriam Finally, run the sorted list through `uniq', to weed out duplicates: $ who | cut -c1-8 | sort | uniq arnold bill miriam The `sort' command actually has a `-u' option that does what `uniq' does. However, `uniq' has other uses for which one cannot substitute `sort -u'. The SysOp puts this pipeline into a shell script, and makes it available for all the users on the system: # cat > /usr/local/bin/listusers who | cut -c1-8 | sort | uniq ^D # chmod +x /usr/local/bin/listusers There are four major points to note here. First, with just four programs, on one command line, the SysOp was able to save about two hours worth of work. Furthermore, the shell pipeline is just about as efficient as the C program would be, and it is much more efficient in terms of programmer time. People time is much more expensive than computer time, and in our modern "there's never enough time to do everything" society, saving two hours of programmer time is no mean feat. Second, it is also important to emphasize that with the *combination* of the tools, it is possible to do a special purpose job never imagined by the authors of the individual programs. Third, it is also valuable to build up your pipeline in stages, as we did here. This allows you to view the data at each stage in the pipeline, which helps you acquire the confidence that you are indeed using these tools correctly. Finally, by bundling the pipeline in a shell script, other users can use your command, without having to remember the fancy plumbing you set up for them. In terms of how you run them, shell scripts and compiled programs are indistinguishable. After the previous warm-up exercise, we'll look at two additional, more complicated pipelines. For them, we need to introduce two more tools. The first is the `tr' command, which stands for "transliterate." The `tr' command works on a character-by-character basis, changing characters. Normally it is used for things like mapping upper case to lower case: $ echo ThIs ExAmPlE HaS MIXED case! | tr '[A-Z]' '[a-z]' this example has mixed case! There are several options of interest: `-c' work on the complement of the listed characters, i.e., operations apply to characters not in the given set `-d' delete characters in the first set from the output `-s' squeeze repeated characters in the output into just one character. We will be using all three options in a moment. The other command we'll look at is `comm'. The `comm' command takes two sorted input files as input data, and prints out the files' lines in three columns. The output columns are the data lines unique to the first file, the data lines unique to the second file, and the data lines that are common to both. The `-1', `-2', and `-3' command line options omit the respective columns. (This is non-intuitive and takes a little getting used to.) For example: $ cat f1 11111 22222 33333 44444 $ cat f2 00000 22222 33333 55555 $ comm f1 f2 00000 11111 22222 33333 44444 55555 The single dash as a filename tells `comm' to read standard input instead of a regular file. Now we're ready to build a fancy pipeline. The first application is a word frequency counter. This helps an author determine if he or she is over-using certain words. The first step is to change the case of all the letters in our input file to one case. "The" and "the" are the same word when doing counting. $ tr '[A-Z]' '[a-z]' < whats.gnu | ... The next step is to get rid of punctuation. Quoted words and unquoted words should be treated identically; it's easiest to just get the punctuation out of the way. $ tr '[A-Z]' '[a-z]' < whats.gnu | tr -cd '[A-Za-z0-9_ \012]' | ... The second `tr' command operates on the complement of the listed characters, which are all the letters, the digits, the underscore, and the blank. The `\012' represents the newline character; it has to be left alone. (The ASCII TAB character should also be included for good measure in a production script.) At this point, we have data consisting of words separated by blank space. The words only contain alphanumeric characters (and the underscore). The next step is break the data apart so that we have one word per line. This makes the counting operation much easier, as we will see shortly. $ tr '[A-Z]' '[a-z]' < whats.gnu | tr -cd '[A-Za-z0-9_ \012]' | > tr -s '[ ]' '\012' | ... This command turns blanks into newlines. The `-s' option squeezes multiple newline characters in the output into just one. This helps us avoid blank lines. (The `>' is the shell's "secondary prompt." This is what the shell prints when it notices you haven't finished typing in all of a command.) We now have data consisting of one word per line, no punctuation, all one case. We're ready to count each word: $ tr '[A-Z]' '[a-z]' < whats.gnu | tr -cd '[A-Za-z0-9_ \012]' | > tr -s '[ ]' '\012' | sort | uniq -c | ... At this point, the data might look something like this: 60 a 2 able 6 about 1 above 2 accomplish 1 acquire 1 actually 2 additional The output is sorted by word, not by count! What we want is the most frequently used words first. Fortunately, this is easy to accomplish, with the help of two more `sort' options: `-n' do a numeric sort, not an ASCII one `-r' reverse the order of the sort The final pipeline looks like this: $ tr '[A-Z]' '[a-z]' < whats.gnu | tr -cd '[A-Za-z0-9_ \012]' | > tr -s '[ ]' '\012' | sort | uniq -c | sort -nr 156 the 60 a 58 to 51 of 51 and ... Whew! That's a lot to digest. Yet, the same principles apply. With six commands, on two lines (really one long one split for convenience), we've created a program that does something interesting and useful, in much less time than we could have written a C program to do the same thing. A minor modification to the above pipeline can give us a simple spelling checker! To determine if you've spelled a word correctly, all you have to do is look it up in a dictionary. If it is not there, then chances are that your spelling is incorrect. So, we need a dictionary. If you have the Slackware Linux distribution, you have the file `/usr/lib/ispell/ispell.words', which is a sorted, 38,400 word dictionary. Now, how to compare our file with the dictionary? As before, we generate a sorted list of words, one per line: $ tr '[A-Z]' '[a-z]' < whats.gnu | tr -cd '[A-Za-z0-9_ \012]' | > tr -s '[ ]' '\012' | sort -u | ... Now, all we need is a list of words that are *not* in the dictionary. Here is where the `comm' command comes in. $ tr '[A-Z]' '[a-z]' < whats.gnu | tr -cd '[A-Za-z0-9_ \012]' | > tr -s '[ ]' '\012' | sort -u | > comm -23 - /usr/lib/ispell/ispell.words The `-2' and `-3' options eliminate lines that are only in the dictionary (the second file), and lines that are in both files. Lines only in the first file (standard input, our stream of words), are words that are not in the dictionary. These are likely candidates for spelling errors. This pipeline was the first cut at a production spelling checker on Unix. There are some other tools that deserve brief mention. `grep' search files for text that matches a regular expression `egrep' like `grep', but with more powerful regular expressions `wc' count lines, words, characters `tee' a T-fitting for data pipes, copies data to files and to standard output `sed' the stream editor, an advanced tool `awk' a data manipulation language, another advanced tool The software tools philosophy also espoused the following bit of advice: "Let someone else do the hard part." This means, take something that gives you most of what you need, and then massage it the rest of the way until it's in the form that you want. To summarize: 1. Each program should do one thing well. No more, no less. 2. Combining programs with appropriate plumbing leads to results where the whole is greater than the sum of the parts. It also leads to novel uses of programs that the authors might never have imagined. 3. Programs should never print extraneous header or trailer data, since these could get sent on down a pipeline. (A point we didn't mention earlier.) 4. Let someone else do the hard part. 5. Know your toolbox! Use each program appropriately. If you don't have an appropriate tool, build one. As of this writing, all the programs we've discussed are available via anonymous `ftp' from `prep.ai.mit.edu' as `/pub/gnu/textutils-1.9.tar.gz' directory.(1) None of what I have presented in this column is new. The Software Tools philosophy was first introduced in the book `Software Tools', by Brian Kernighan and P.J. Plauger (Addison-Wesley, ISBN 0-201-03669-X). This book showed how to write and use software tools. It was written in 1976, using a preprocessor for FORTRAN named `ratfor' (RATional FORtran). At the time, C was not as ubiquitous as it is now; FORTRAN was. The last chapter presented a `ratfor' to FORTRAN processor, written in `ratfor'. `ratfor' looks an awful lot like C; if you know C, you won't have any problem following the code. In 1981, the book was updated and made available as `Software Tools in Pascal' (Addison-Wesley, ISBN 0-201-10342-7). Both books remain in print, and are well worth reading if you're a programmer. They certainly made a major change in how I view programming. Initially, the programs in both books were available (on 9-track tape) from Addison-Wesley. Unfortunately, this is no longer the case, although you might be able to find copies floating around the Internet. For a number of years, there was an active Software Tools Users Group, whose members had ported the original `ratfor' programs to essentially every computer system with a FORTRAN compiler. The popularity of the group waned in the middle '80s as Unix began to spread beyond universities. With the current proliferation of GNU code and other clones of Unix programs, these programs now receive little attention; modern C versions are much more efficient and do more than these programs do. Nevertheless, as exposition of good programming style, and evangelism for a still-valuable philosophy, these books are unparalleled, and I recommend them highly. Acknowledgement: I would like to express my gratitude to Brian Kernighan of Bell Labs, the original Software Toolsmith, for reviewing this column. ---------- Footnotes ---------- (1) Version 1.9 was current when this column was written. Check the nearest GNU archive for the current version.  File: textutils.info, Node: Index, Prev: Opening the software toolbox, Up: Top Index ***** * Menu: * +COUNT: tail invocation. * +N: uniq invocation. * -address-radix: od invocation. * -all: unexpand invocation. * -before: tac invocation. * -binary: md5sum invocation. * -body-numbering: nl invocation. * -bytes: fold invocation. * -bytes: split invocation. * -bytes: cut invocation. * -bytes: head invocation. * -bytes: wc invocation. * -bytes: tail invocation. * -characters: cut invocation. * -chars: wc invocation. * -check-chars: uniq invocation. * -count: uniq invocation. * -crown-margin: fmt invocation. * -delimiter: cut invocation. * -delimiters: paste invocation. * -digits: csplit invocation. * -elide-empty-files: csplit invocation. * -fields: cut invocation. * -first-page: nl invocation. * -follow: tail invocation. * -footer-numbering: nl invocation. * -format: od invocation. * -header-numbering: nl invocation. * -help: Common options. * -initial: expand invocation. * -join-blank-lines: nl invocation. * -keep-files: csplit invocation. * -line-bytes: split invocation. * -lines: wc invocation. * -lines: split invocation. * -lines: tail invocation. * -lines: head invocation. * -no-renumber: nl invocation. * -number: cat invocation. * -number-format: nl invocation. * -number-nonblank: cat invocation. * -number-separator: nl invocation. * -number-width: nl invocation. * -only-delimited: cut invocation. * -output-duplicates: od invocation. * -page-increment: nl invocation. * -prefix: csplit invocation. * -quiet: tail invocation. * -quiet: csplit invocation. * -quiet: head invocation. * -read-bytes: od invocation. * -regex: tac invocation. * -repeated: uniq invocation. * -section-delimiter: nl invocation. * -separator: tac invocation. * -serial: paste invocation. * -show-all: cat invocation. * -show-ends: cat invocation. * -show-nonprinting: cat invocation. * -show-tabs: cat invocation. * -silent: head invocation. * -silent: tail invocation. * -silent: csplit invocation. * -skip-bytes: od invocation. * -skip-chars: uniq invocation. * -skip-fields: uniq invocation. * -spaces: fold invocation. * -split-only: fmt invocation. * -squeeze-blank: cat invocation. * -string: md5sum invocation. * -strings: od invocation. * -suffix: csplit invocation. * -sysv: sum invocation. * -tabs: expand invocation. * -tabs: unexpand invocation. * -tagged-paragraph: fmt invocation. * -text: md5sum invocation. * -traditional: od invocation. * -uniform-spacing: fmt invocation. * -unique: uniq invocation. * -verbose: md5sum invocation. * -verbose: tail invocation. * -verbose: head invocation. * -version: Common options. * -width: fold invocation. * -width: od invocation. * -width: fmt invocation. * -words: wc invocation. * -1: join invocation. * -1: comm invocation. * -2: comm invocation. * -2: join invocation. * -3: comm invocation. * -COLUMN: pr invocation. * -COUNT: head invocation. * textutils.texi: tail invocation. * -N: uniq invocation. * -TAB: expand invocation. * -TAB: unexpand invocation. * -WIDTH: fmt invocation. * -a: od invocation. * -a: pr invocation. * -A: cat invocation. * -a: join invocation. * -A: od invocation. * -a: unexpand invocation. * -b: tac invocation. * -b: od invocation. * -b: split invocation. * -b: nl invocation. * -b: csplit invocation. * -b: cut invocation. * -b: sort invocation. * -b: cat invocation. * -b: fold invocation. * -b: pr invocation. * -b: md5sum invocation. * -c: fmt invocation. * -c: od invocation. * -c: sort invocation. * -c: wc invocation. * -c: head invocation. * -C: split invocation. * -c: uniq invocation. * -c: pr invocation. * -c: cut invocation. * -c: tail invocation. * -d: paste invocation. * -d: cut invocation. * -d: uniq invocation. * -d: sort invocation. * -d: pr invocation. * -d: od invocation. * -d: nl invocation. * -e: pr invocation. * -e: cat invocation. * -E: cat invocation. * -e: join invocation. * -F: pr invocation. * -f: uniq invocation. * -f: csplit invocation. * -f: sort invocation. * -f: od invocation. * -f: cut invocation. * -f: pr invocation. * -f: nl invocation. * -f: tail invocation. * -h: pr invocation. * -h: od invocation. * -h: nl invocation. * -i: od invocation. * -i: expand invocation. * -i: pr invocation. * -i: sort invocation. * -i: nl invocation. * -j: od invocation. * -j1: join invocation. * -j2: join invocation. * -k: csplit invocation. * -k: sort invocation. * -l: split invocation. * -l: wc invocation. * -l: pr invocation. * -l: nl invocation. * -l: od invocation. * -m: pr invocation. * -m: sort invocation. * -M: sort invocation. * -n: sort invocation. * -n: nl invocation. * -n: cut invocation. * -n: tail invocation. * -N: od invocation. * -n: cat invocation. * -n: head invocation. * -n: csplit invocation. * -n: pr invocation. * -o: sort invocation. * -o: od invocation. * -o: pr invocation. * -p: nl invocation. * -q: head invocation. * -q: csplit invocation. * -q: tail invocation. * -r: sort invocation. * -r: sum invocation. * -r: tac invocation. * -r: pr invocation. * -s: tac invocation. * -s: md5sum invocation. * -s: cat invocation. * -s: sum invocation. * -s: fold invocation. * -s: nl invocation. * -s: csplit invocation. * -s: od invocation. * -s: paste invocation. * -s: cut invocation. * -s: fmt invocation. * -s: pr invocation. * -s: uniq invocation. * -t: expand invocation. * -t: sort invocation. * -T: cat invocation. * -t: od invocation. * -t: fmt invocation. * -t: pr invocation. * -t: md5sum invocation. * -t: unexpand invocation. * -t: cat invocation. * -u: fmt invocation. * -u: sort invocation. * -u: cat invocation. * -u: uniq invocation. * -v: od invocation. * -v: md5sum invocation. * -v: nl invocation. * -v: cat invocation. * -v: pr invocation. * -v: tail invocation. * -v: head invocation. * -w: fmt invocation. * -w: wc invocation. * -w: fold invocation. * -w: uniq invocation. * -w: pr invocation. * -w: od invocation. * var: nl invocation. * -x: od invocation. * -z: csplit invocation. * 128-bit checksum: md5sum invocation. * 16-bit checksum: sum invocation. * across columns: pr invocation. * alnum: Character sets. * alpha: Character sets. * ASCII dump of files: od invocation. * backslash escapes: Character sets. * balancing columns: pr invocation. * binary input files: md5sum invocation. * blank: Character sets. * blank lines, numbering: nl invocation. * blanks, ignoring leading: sort invocation. * body, numbering: nl invocation. * BSD sum: sum invocation. * BSD tail: tail invocation. * bugs, reporting: Introduction. * byte count: wc invocation. * case folding: sort invocation. * cat: cat invocation. * characters classes: Character sets. * checking for sortedness: sort invocation. * checksum, 128-bit: md5sum invocation. * checksum, 16-bit: sum invocation. * cksum: cksum invocation. * cntrl: Character sets. * comm: comm invocation. * common field, joining on: join invocation. * common lines: comm invocation. * common options: Common options. * comparing sorted files: comm invocation. * concatenate and write files: cat invocation. * context splitting: csplit invocation. * converting tabs to spaces: expand invocation. * copying files: cat invocation. * CRC checksum: cksum invocation. * crown margin: fmt invocation. * csplit: csplit invocation. * cut: cut invocation. * cyclic redundancy check: cksum invocation. * deleting characters: Squeezing. * differing lines: comm invocation. * digit: Character sets. * double spacing: pr invocation. * duplicate lines, outputting: uniq invocation. * empty lines, numbering: nl invocation. * entire files, output of: Output of entire files. * equivalence classes: Character sets. * expand: expand invocation. * field separator character: sort invocation. * file contents, dumping unambiguously: od invocation. * file offset radix: od invocation. * fingerprint, 128-bit: md5sum invocation. * first part of files, outputting: head invocation. * fmt: fmt invocation. * fold: fold invocation. * folding long input lines: fold invocation. * footers, numbering: nl invocation. * formatting file contents: Formatting file contents. * graph: Character sets. * growing files: tail invocation. * head: head invocation. * headers, numbering: nl invocation. * help, online: Common options. * hex dump of files: od invocation. * indenting lines: pr invocation. * initial part of files, outputting: head invocation. * initial tabs, converting: expand invocation. * input tabs: pr invocation. * introduction: Introduction. * join: join invocation. * Knuth, Donald E.: fmt invocation. * last part of files, outputting: tail invocation. * left margin: pr invocation. * line count: wc invocation. * line numbering: nl invocation. * line-breaking: fmt invocation. * line-by-line comparison: comm invocation. * ln format for nl: nl invocation. * logical pages, numbering on: nl invocation. * lower: Character sets. * md5sum: md5sum invocation. * merging files: paste invocation. * merging sorted files: sort invocation. * message-digest, 128-bit: md5sum invocation. * months, sorting by: sort invocation. * multicolumn output, generating: pr invocation. * nl: nl invocation. * numbering lines: nl invocation. * numeric sort: sort invocation. * octal dump of files: od invocation. * od: od invocation. * operating on characters: Operating on characters. * operating on sorted files: Operating on sorted files. * output file name prefix: csplit invocation. * : split invocation. * output file name suffix: csplit invocation. * output of entire files: Output of entire files. * output of parts of files: Output of parts of files. * output tabs: pr invocation. * overwriting of input, allowed: sort invocation. * paragraphs, reformatting: fmt invocation. * parts of files, output of: Output of parts of files. * paste: paste invocation. * phone directory order: sort invocation. * pieces, splitting a file into: split invocation. * Plass, Michael F.: fmt invocation. * POSIX.2: Introduction. * POSIXLY_CORRECT: Warnings in tr. * pr: pr invocation. * print: Character sets. * printing, preparing files for: pr invocation. * punct: Character sets. * radix for file offsets: od invocation. * ranges: Character sets. * reformatting paragraph text: fmt invocation. * repeated characters: Character sets. * reverse sorting: sort invocation. * reversing files: tac invocation. * rn format for nl: nl invocation. * rz format for nl: nl invocation. * screen columns: fold invocation. * section delimiters of pages: nl invocation. * sentences and line-breaking: fmt invocation. * sort: sort invocation. * sort field: sort invocation. * sorted files, operations on: Operating on sorted files. * sorting files: sort invocation. * space: Character sets. * specifying sets of characters: Character sets. * split: split invocation. * splitting a file into pieces: split invocation. * splitting a file into pieces by context: csplit invocation. * squeezing blank lines: cat invocation. * squeezing repeat characters: Squeezing. * string constants, outputting: od invocation. * sum: sum invocation. * summarizing files: Summarizing files. * System V sum: sum invocation. * tabs to spaces, converting: expand invocation. * tabstops, setting: expand invocation. * tac: tac invocation. * tagged paragraphs: fmt invocation. * tail: tail invocation. * telephone directory order: sort invocation. * text input files: md5sum invocation. * text utilities: Top. * text, reformatting: fmt invocation. * TMPDIR: sort invocation. * total counts: wc invocation. * tr: tr invocation. * translating characters: Translating. * type size: od invocation. * unexpand: unexpand invocation. * uniq: uniq invocation. * uniqify files: uniq invocation. * uniqifying output: sort invocation. * unique lines, outputting: uniq invocation. * unprintable characters, ignoring: sort invocation. * upper: Character sets. * utilities for text handling: Top. * version number, finding: Common options. * wc: wc invocation. * word count: wc invocation. * wrapping long input lines: fold invocation. * xdigit: Character sets.  Tag Table: Node: Top2463 Node: Introduction3277 Node: Common options4524 Node: Output of entire files5247 Node: cat invocation5779 Node: tac invocation6871 Node: nl invocation7849 Node: od invocation11514 Node: Formatting file contents17080 Node: fmt invocation17518 Node: pr invocation20221 Node: fold invocation23638 Node: Output of parts of files24880 Node: head invocation25387 Node: tail invocation26798 Node: split invocation29180 Node: csplit invocation30703 Node: Summarizing files34739 Node: wc invocation35254 Node: sum invocation36416 Node: cksum invocation37729 Node: md5sum invocation38790 Node: Operating on sorted files40341 Node: sort invocation40763 Node: uniq invocation47642 Node: comm invocation49247 Node: Operating on fields within a line50018 Node: cut invocation50418 Node: paste invocation52120 Node: join invocation52963 Node: Operating on characters55246 Node: tr invocation55692 Node: Character sets56809 Node: Translating60405 Node: Squeezing62202 Node: Warnings in tr63439 Node: expand invocation64572 Node: unexpand invocation65889 Node: Opening the software toolbox67324 Node: Toolbox introduction67816 Node: I/O redirection70538 Node: The `who' command73376 Node: The `cut' command74268 Node: The `sort' command75149 Node: The `uniq' command75866 Node: Putting the tools together76599 Node: Index88556  End Tag Table textutils-1.12/doc/version.texi100666 74504 13 74 5770372275 15670 0ustar meyeringuser@set VERSION 1.12 @set RELEASEDATE Fri 16 Jun 1995 17:16:45