mmdb-1.25.5/0000775000175000017500000000000012210630167007524 500000000000000mmdb-1.25.5/INSTALL0000775000175000017500000003633211736610510010511 00000000000000Installation Instructions ************************* Copyright (C) 1994, 1995, 1996, 1999, 2000, 2001, 2002, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. Copying and distribution of this file, with or without modification, are permitted in any medium without royalty provided the copyright notice and this notice are preserved. This file is offered as-is, without warranty of any kind. Basic Installation ================== Briefly, the shell commands `./configure; make; make install' should configure, build, and install this package. The following more-detailed instructions are generic; see the `README' file for instructions specific to this package. Some packages provide this `INSTALL' file but do not implement all of the features documented below. The lack of an optional feature in a given package is not necessarily a bug. More recommendations for GNU packages can be found in *note Makefile Conventions: (standards)Makefile Conventions. 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, and a file `config.log' containing compiler output (useful mainly for debugging `configure'). It can also use an optional file (typically called `config.cache' and enabled with `--cache-file=config.cache' or simply `-C') that saves the results of its tests to speed up reconfiguring. Caching is disabled by default to prevent problems with accidental use of stale cache files. 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 you are using the cache, and at some point `config.cache' contains results you don't want to keep, you may remove or edit it. The file `configure.ac' (or `configure.in') is used to create `configure' by a program called `autoconf'. You need `configure.ac' 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. Running `configure' might take a while. 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, generally using the just-built uninstalled binaries. 4. Type `make install' to install the programs and any data files and documentation. When installing into a prefix owned by root, it is recommended that the package be configured and built as a regular user, and only the `make install' phase executed with root privileges. 5. Optionally, type `make installcheck' to repeat any self-tests, but this time using the binaries in their final installed location. This target does not install anything. Running this target as a regular user, particularly if the prior `make install' required root privileges, verifies that the installation completed correctly. 6. 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. 7. Often, you can also type `make uninstall' to remove the installed files again. In practice, not all packages have tested that uninstallation works correctly, even though it is required by the GNU Coding Standards. 8. Some packages, particularly those that use Automake, provide `make distcheck', which can by used by developers to test that all other targets like `make install' and `make uninstall' work correctly. This target is generally not run by end users. Compilers and Options ===================== Some systems require unusual options for compilation or linking that the `configure' script does not know about. Run `./configure --help' for details on some of the pertinent environment variables. You can give `configure' initial values for configuration parameters by setting variables in the command line or in the environment. Here is an example: ./configure CC=c99 CFLAGS=-g LIBS=-lposix *Note Defining Variables::, for more details. 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 can use 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 `..'. This is known as a "VPATH" build. With a non-GNU `make', it is safer 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. On MacOS X 10.5 and later systems, you can create libraries and executables that work on multiple system types--known as "fat" or "universal" binaries--by specifying multiple `-arch' options to the compiler but only a single `-arch' option to the preprocessor. Like this: ./configure CC="gcc -arch i386 -arch x86_64 -arch ppc -arch ppc64" \ CXX="g++ -arch i386 -arch x86_64 -arch ppc -arch ppc64" \ CPP="gcc -E" CXXCPP="g++ -E" This is not guaranteed to produce working output in all cases, you may have to build one architecture at a time and combine the results using the `lipo' tool if you have problems. Installation Names ================== By default, `make install' installs the package's commands under `/usr/local/bin', include files under `/usr/local/include', etc. You can specify an installation prefix other than `/usr/local' by giving `configure' the option `--prefix=PREFIX', where PREFIX must be an absolute file name. You can specify separate installation prefixes for architecture-specific files and architecture-independent files. If you pass the option `--exec-prefix=PREFIX' to `configure', the package uses PREFIX as the prefix for installing programs and libraries. Documentation and other data files still use the regular prefix. In addition, if you use an unusual directory layout you can give options like `--bindir=DIR' to specify different values for particular kinds of files. Run `configure --help' for a list of the directories you can set and what kinds of files go in them. In general, the default for these options is expressed in terms of `${prefix}', so that specifying just `--prefix' will affect all of the other directory specifications that were not explicitly provided. The most portable way to affect installation locations is to pass the correct locations to `configure'; however, many packages provide one or both of the following shortcuts of passing variable assignments to the `make install' command line to change installation locations without having to reconfigure or recompile. The first method involves providing an override variable for each affected directory. For example, `make install prefix=/alternate/directory' will choose an alternate location for all directory configuration variables that were expressed in terms of `${prefix}'. Any directories that were specified during `configure', but not in terms of `${prefix}', must each be overridden at install time for the entire installation to be relocated. The approach of makefile variable overrides for each directory variable is required by the GNU Coding Standards, and ideally causes no recompilation. However, some platforms have known limitations with the semantics of shared libraries that end up requiring recompilation when using this method, particularly noticeable in packages that use GNU Libtool. The second method involves providing the `DESTDIR' variable. For example, `make install DESTDIR=/alternate/directory' will prepend `/alternate/directory' before all installation names. The approach of `DESTDIR' overrides is not required by the GNU Coding Standards, and does not work on platforms that have drive letters. On the other hand, it does better at avoiding recompilation issues, and works well even when some directory options were not specified in terms of `${prefix}' at `configure' time. Optional Features ================= 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'. 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. Some packages offer the ability to configure how verbose the execution of `make' will be. For these packages, running `./configure --enable-silent-rules' sets the default to minimal output, which can be overridden with `make V=1'; while running `./configure --disable-silent-rules' sets the default to verbose, which can be overridden with `make V=0'. Particular systems ================== On HP-UX, the default C compiler is not ANSI C compatible. If GNU CC is not installed, it is recommended to use the following options in order to use an ANSI C compiler: ./configure CC="cc -Ae -D_XOPEN_SOURCE=500" and if that doesn't work, install pre-built binaries of GCC for HP-UX. On OSF/1 a.k.a. Tru64, some versions of the default C compiler cannot parse its `' header file. The option `-nodtk' can be used as a workaround. If GNU CC is not installed, it is therefore recommended to try ./configure CC="cc" and if that doesn't work, try ./configure CC="cc -nodtk" On Solaris, don't put `/usr/ucb' early in your `PATH'. This directory contains several dysfunctional programs; working variants of these programs are available in `/usr/bin'. So, if you need `/usr/ucb' in your `PATH', put it _after_ `/usr/bin'. On Haiku, software installed for all users goes in `/boot/common', not `/usr/local'. It is recommended to use the following options: ./configure --prefix=/boot/common Specifying the System Type ========================== There may be some features `configure' cannot figure out automatically, but needs to determine by the type of machine the package will run on. Usually, assuming the package is built to be run on the _same_ architectures, `configure' can figure that out, but if it prints a message saying it cannot guess the machine type, give it the `--build=TYPE' option. TYPE can either be a short name for the system type, such as `sun4', or a canonical name which has the form: CPU-COMPANY-SYSTEM where SYSTEM can have one of these forms: OS KERNEL-OS 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 machine type. If you are _building_ compiler tools for cross-compiling, you should use the option `--target=TYPE' to select the type of system they will produce code for. If you want to _use_ a cross compiler, that generates code for a platform different from the build platform, you should specify the "host" platform (i.e., that on which the generated programs will eventually be run) with `--host=TYPE'. 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. Defining Variables ================== Variables not defined in a site shell script can be set in the environment passed to `configure'. However, some packages may run configure again during the build, and the customized values of these variables may be lost. In order to avoid this problem, you should set them in the `configure' command line, using `VAR=value'. For example: ./configure CC=/usr/local2/bin/gcc causes the specified `gcc' to be used as the C compiler (unless it is overridden in the site shell script). Unfortunately, this technique does not work for `CONFIG_SHELL' due to an Autoconf bug. Until the bug is fixed you can use this workaround: CONFIG_SHELL=/bin/bash /bin/bash ./configure CONFIG_SHELL=/bin/bash `configure' Invocation ====================== `configure' recognizes the following options to control how it operates. `--help' `-h' Print a summary of all of the options to `configure', and exit. `--help=short' `--help=recursive' Print a summary of the options unique to this package's `configure', and exit. The `short' variant lists options used only in the top level, while the `recursive' variant lists options also present in any nested packages. `--version' `-V' Print the version of Autoconf used to generate the `configure' script, and exit. `--cache-file=FILE' Enable the cache: use and save the results of the tests in FILE, traditionally `config.cache'. FILE defaults to `/dev/null' to disable caching. `--config-cache' `-C' Alias for `--cache-file=config.cache'. `--quiet' `--silent' `-q' Do not print messages saying which checks are being made. To suppress all normal output, redirect it to `/dev/null' (any error messages will still be shown). `--srcdir=DIR' Look for the package's source code in directory DIR. Usually `configure' can determine that directory automatically. `--prefix=DIR' Use DIR as the installation prefix. *note Installation Names:: for more details, including other options available for fine-tuning the installation locations. `--no-create' `-n' Run the configure checks, but stop before creating any output files. `configure' also accepts some other, not widely useful, options. Run `configure --help' for more details. mmdb-1.25.5/COPYING.LESSER0000775000175000017500000001672711736610510011515 00000000000000 GNU LESSER GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. This version of the GNU Lesser General Public License incorporates the terms and conditions of version 3 of the GNU General Public License, supplemented by the additional permissions listed below. 0. Additional Definitions. As used herein, "this License" refers to version 3 of the GNU Lesser General Public License, and the "GNU GPL" refers to version 3 of the GNU General Public License. "The Library" refers to a covered work governed by this License, other than an Application or a Combined Work as defined below. An "Application" is any work that makes use of an interface provided by the Library, but which is not otherwise based on the Library. Defining a subclass of a class defined by the Library is deemed a mode of using an interface provided by the Library. A "Combined Work" is a work produced by combining or linking an Application with the Library. The particular version of the Library with which the Combined Work was made is also called the "Linked Version". The "Minimal Corresponding Source" for a Combined Work means the Corresponding Source for the Combined Work, excluding any source code for portions of the Combined Work that, considered in isolation, are based on the Application, and not on the Linked Version. The "Corresponding Application Code" for a Combined Work means the object code and/or source code for the Application, including any data and utility programs needed for reproducing the Combined Work from the Application, but excluding the System Libraries of the Combined Work. 1. Exception to Section 3 of the GNU GPL. You may convey a covered work under sections 3 and 4 of this License without being bound by section 3 of the GNU GPL. 2. Conveying Modified Versions. If you modify a copy of the Library, and, in your modifications, a facility refers to a function or data to be supplied by an Application that uses the facility (other than as an argument passed when the facility is invoked), then you may convey a copy of the modified version: a) under this License, provided that you make a good faith effort to ensure that, in the event an Application does not supply the function or data, the facility still operates, and performs whatever part of its purpose remains meaningful, or b) under the GNU GPL, with none of the additional permissions of this License applicable to that copy. 3. Object Code Incorporating Material from Library Header Files. The object code form of an Application may incorporate material from a header file that is part of the Library. You may convey such object code under terms of your choice, provided that, if the incorporated material is not limited to numerical parameters, data structure layouts and accessors, or small macros, inline functions and templates (ten or fewer lines in length), you do both of the following: a) Give prominent notice with each copy of the object code that the Library is used in it and that the Library and its use are covered by this License. b) Accompany the object code with a copy of the GNU GPL and this license document. 4. Combined Works. You may convey a Combined Work under terms of your choice that, taken together, effectively do not restrict modification of the portions of the Library contained in the Combined Work and reverse engineering for debugging such modifications, if you also do each of the following: a) Give prominent notice with each copy of the Combined Work that the Library is used in it and that the Library and its use are covered by this License. b) Accompany the Combined Work with a copy of the GNU GPL and this license document. c) For a Combined Work that displays copyright notices during execution, include the copyright notice for the Library among these notices, as well as a reference directing the user to the copies of the GNU GPL and this license document. d) Do one of the following: 0) Convey the Minimal Corresponding Source under the terms of this License, and the Corresponding Application Code in a form suitable for, and under terms that permit, the user to recombine or relink the Application with a modified version of the Linked Version to produce a modified Combined Work, in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source. 1) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (a) uses at run time a copy of the Library already present on the user's computer system, and (b) will operate properly with a modified version of the Library that is interface-compatible with the Linked Version. e) Provide Installation Information, but only if you would otherwise be required to provide such information under section 6 of the GNU GPL, and only to the extent that such information is necessary to install and execute a modified version of the Combined Work produced by recombining or relinking the Application with a modified version of the Linked Version. (If you use option 4d0, the Installation Information must accompany the Minimal Corresponding Source and Corresponding Application Code. If you use option 4d1, you must provide the Installation Information in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source.) 5. Combined Libraries. You may place library facilities that are a work based on the Library side by side in a single library together with other library facilities that are not Applications and are not covered by this License, and convey such a combined library under terms of your choice, if you do both of the following: a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities, conveyed under the terms of this License. b) Give prominent notice with the combined library that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 6. Revised Versions of the GNU Lesser General Public License. The Free Software Foundation may publish revised and/or new versions of the GNU Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Library as you received it specifies that a certain numbered version of the GNU Lesser General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that published version or of any later version published by the Free Software Foundation. If the Library as you received it does not specify a version number of the GNU Lesser General Public License, you may choose any version of the GNU Lesser General Public License ever published by the Free Software Foundation. If the Library as you received it specifies that a proxy can decide whether future versions of the GNU Lesser General Public License shall apply, that proxy's public statement of acceptance of any version is permanent authorization for you to choose that version for the Library. mmdb-1.25.5/COPYING0000775000175000017500000010531211736610510010506 00000000000000 GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The GNU General Public License is a free, copyleft license for software and other kinds of works. The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things. To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others. For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it. For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions. Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users. Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free. The precise terms and conditions for copying, distribution and modification follow. TERMS AND CONDITIONS 0. Definitions. "This License" refers to version 3 of the GNU General Public License. "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks. "The Program" refers to any copyrightable work licensed under this License. Each licensee is addressed as "you". "Licensees" and "recipients" may be individuals or organizations. To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work. A "covered work" means either the unmodified Program or a work based on the Program. To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well. To "convey" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying. An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion. 1. Source Code. The "source code" for a work means the preferred form of the work for making modifications to it. "Object code" means any non-source form of a work. A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language. The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it. The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work. The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source. The Corresponding Source for a work in source code form is that same work. 2. Basic Permissions. All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law. You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you. Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary. 3. Protecting Users' Legal Rights From Anti-Circumvention Law. No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures. When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures. 4. Conveying Verbatim Copies. You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program. You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee. 5. Conveying Modified Source Versions. You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions: a) The work must carry prominent notices stating that you modified it, and giving a relevant date. b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to "keep intact all notices". c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it. d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so. A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate. 6. Conveying Non-Source Forms. You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways: a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange. b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge. c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b. d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements. e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d. A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work. A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product. "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made. If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM). The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network. Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying. 7. Additional Terms. "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions. When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission. Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms: a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or d) Limiting the use for publicity purposes of names of licensors or authors of the material; or e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors. All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying. If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms. Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way. 8. Termination. You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11). However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation. Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice. Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10. 9. Acceptance Not Required for Having Copies. You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so. 10. Automatic Licensing of Downstream Recipients. Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License. An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it. 11. Patents. A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's "contributor version". A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License. Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version. In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party. If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid. If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it. A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007. Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law. 12. No Surrender of Others' Freedom. If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program. 13. Use with the GNU Affero General Public License. Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such. 14. Revised Versions of this License. The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation. If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program. Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version. 15. Disclaimer of Warranty. Section 15 has been amended in accordance with Section 7a) above to address the requirements of UK law. 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 FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. Limitation of Liability. Section 16 has been replaced in accordance with Section 7a) above to address the requirements of UK law. THE LICENSOR OR ANY THIRD PARTIES FROM WHOM IT HAS LICENSED ANY CODE WILL NOT BE LIABLE FOR: ANY LOSS OF PROFITS, LOSS OF REVENUE, LOSS OR CORRUPTION OF DATA, LOSS OF CONTRACTS OR OPPORTUNITY, LOSS OF SAVINGS OR THIRD PARTY CLAIMS (IN EACH CASE WHETHER DIRECT OR INDIRECT), ANY DIRECT OR INDIRECT LOSS OR DAMAGE ARISING OUT OF OR IN CONNECTION WITH THE PROGRAM, IN EACH CASE, WHETHER THAT LOSS ARISES AS A RESULT OF LICENSOR"S NEGLIGENCE, OR IN ANY OTHER WAY, EVEN IF LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF THAT LOSS ARISING, OR IF IT WAS WITHIN LICENSOR'S CONTEMPLATION. NONE OF THESE PROVISION LIMITS OR EXCLUDES THE LICENSOR"S LIABILITY FOR DEATH OR PERSONAL INJURY CAUSED BY ITS NEGLIGENCE OR FOR ANY FRAUD, OR FOR ANY SORT OF LIABILITY THAT, BY LAW, CANNOT BE LIMITED OR EXCLUDED 17. Interpretation of Sections 15 and 16. If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . Also add information on how to contact you by electronic and paper mail. If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: Copyright (C) This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an "about box". You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see . The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read . mmdb-1.25.5/AUTHORS0000775000175000017500000000006111736610510010516 00000000000000 Eugene Krissinel (eugene.krissinel@stfc.ac.uk) mmdb-1.25.5/configure0000775000175000017500000207743112210624040011362 00000000000000#! /bin/sh # Guess values for system-dependent variables and create Makefiles. # Generated by GNU Autoconf 2.69 for mmdb 1.25.5. # # # Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc. # # # This configure script is free software; the Free Software Foundation # gives unlimited permission to copy, distribute and modify it. ## -------------------- ## ## M4sh Initialization. ## ## -------------------- ## # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else case `(set -o) 2>/dev/null` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi as_nl=' ' export as_nl # Printing a long string crashes Solaris 7 /usr/bin/printf. as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo # Prefer a ksh shell builtin over an external printf program on Solaris, # but without wasting forks for bash or zsh. if test -z "$BASH_VERSION$ZSH_VERSION" \ && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='print -r --' as_echo_n='print -rn --' elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='printf %s\n' as_echo_n='printf %s' else if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' as_echo_n='/usr/ucb/echo -n' else as_echo_body='eval expr "X$1" : "X\\(.*\\)"' as_echo_n_body='eval arg=$1; case $arg in #( *"$as_nl"*) expr "X$arg" : "X\\(.*\\)$as_nl"; arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; esac; expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" ' export as_echo_n_body as_echo_n='sh -c $as_echo_n_body as_echo' fi export as_echo_body as_echo='sh -c $as_echo_body as_echo' fi # The user is always right. if test "${PATH_SEPARATOR+set}" != set; then PATH_SEPARATOR=: (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || PATH_SEPARATOR=';' } fi # IFS # We need space, tab and new line, in precisely that order. Quoting is # there to prevent editors from complaining about space-tab. # (If _AS_PATH_WALK were called with IFS unset, it would disable word # splitting by setting IFS to empty value.) IFS=" "" $as_nl" # Find who we are. Look in the path if we contain no directory separator. as_myself= case $0 in #(( *[\\/]* ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break done IFS=$as_save_IFS ;; esac # We did not find ourselves, most probably we were run as `sh COMMAND' # in which case we are not to be found in the path. if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 exit 1 fi # Unset variables that we do not need and which cause bugs (e.g. in # pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" # suppresses any "Segmentation fault" message there. '((' could # trigger a bug in pdksh 5.2.14. for as_var in BASH_ENV ENV MAIL MAILPATH do eval test x\${$as_var+set} = xset \ && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : done PS1='$ ' PS2='> ' PS4='+ ' # NLS nuisances. LC_ALL=C export LC_ALL LANGUAGE=C export LANGUAGE # CDPATH. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH # Use a proper internal environment variable to ensure we don't fall # into an infinite loop, continuously re-executing ourselves. if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then _as_can_reexec=no; export _as_can_reexec; # We cannot yet assume a decent shell, so we have to provide a # neutralization value for shells without unset; and this also # works around shells that cannot unset nonexistent variables. # Preserve -v and -x to the replacement shell. BASH_ENV=/dev/null ENV=/dev/null (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV case $- in # (((( *v*x* | *x*v* ) as_opts=-vx ;; *v* ) as_opts=-v ;; *x* ) as_opts=-x ;; * ) as_opts= ;; esac exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} # Admittedly, this is quite paranoid, since all the known shells bail # out after a failed `exec'. $as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 as_fn_exit 255 fi # We don't want this to propagate to other subprocesses. { _as_can_reexec=; unset _as_can_reexec;} if test "x$CONFIG_SHELL" = x; then as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which # is contrary to our usage. Disable this feature. alias -g '\${1+\"\$@\"}'='\"\$@\"' setopt NO_GLOB_SUBST else case \`(set -o) 2>/dev/null\` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi " as_required="as_fn_return () { (exit \$1); } as_fn_success () { as_fn_return 0; } as_fn_failure () { as_fn_return 1; } as_fn_ret_success () { return 0; } as_fn_ret_failure () { return 1; } exitcode=0 as_fn_success || { exitcode=1; echo as_fn_success failed.; } as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; } as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; } as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; } if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then : else exitcode=1; echo positional parameters were not saved. fi test x\$exitcode = x0 || exit 1 test -x / || exit 1" as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" && test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1 test -n \"\${ZSH_VERSION+set}\${BASH_VERSION+set}\" || ( ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' ECHO=\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO ECHO=\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO PATH=/empty FPATH=/empty; export PATH FPATH test \"X\`printf %s \$ECHO\`\" = \"X\$ECHO\" \\ || test \"X\`print -r -- \$ECHO\`\" = \"X\$ECHO\" ) || exit 1 test \$(( 1 + 1 )) = 2 || exit 1" if (eval "$as_required") 2>/dev/null; then : as_have_required=yes else as_have_required=no fi if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then : else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR as_found=false for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. as_found=: case $as_dir in #( /*) for as_base in sh bash ksh sh5; do # Try only shells that exist, to save several forks. as_shell=$as_dir/$as_base if { test -f "$as_shell" || test -f "$as_shell.exe"; } && { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then : CONFIG_SHELL=$as_shell as_have_required=yes if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then : break 2 fi fi done;; esac as_found=false done $as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } && { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then : CONFIG_SHELL=$SHELL as_have_required=yes fi; } IFS=$as_save_IFS if test "x$CONFIG_SHELL" != x; then : export CONFIG_SHELL # We cannot yet assume a decent shell, so we have to provide a # neutralization value for shells without unset; and this also # works around shells that cannot unset nonexistent variables. # Preserve -v and -x to the replacement shell. BASH_ENV=/dev/null ENV=/dev/null (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV case $- in # (((( *v*x* | *x*v* ) as_opts=-vx ;; *v* ) as_opts=-v ;; *x* ) as_opts=-x ;; * ) as_opts= ;; esac exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} # Admittedly, this is quite paranoid, since all the known shells bail # out after a failed `exec'. $as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 exit 255 fi if test x$as_have_required = xno; then : $as_echo "$0: This script requires a shell more modern than all" $as_echo "$0: the shells that I found on your system." if test x${ZSH_VERSION+set} = xset ; then $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should" $as_echo "$0: be upgraded to zsh 4.3.4 or later." else $as_echo "$0: Please tell bug-autoconf@gnu.org about your system, $0: including any error possibly output before this $0: message. Then install a modern shell, or manually run $0: the script under such a shell if you do have one." fi exit 1 fi fi fi SHELL=${CONFIG_SHELL-/bin/sh} export SHELL # Unset more variables known to interfere with behavior of common tools. CLICOLOR_FORCE= GREP_OPTIONS= unset CLICOLOR_FORCE GREP_OPTIONS ## --------------------- ## ## M4sh Shell Functions. ## ## --------------------- ## # as_fn_unset VAR # --------------- # Portably unset VAR. as_fn_unset () { { eval $1=; unset $1;} } as_unset=as_fn_unset # as_fn_set_status STATUS # ----------------------- # Set $? to STATUS, without forking. as_fn_set_status () { return $1 } # as_fn_set_status # as_fn_exit STATUS # ----------------- # Exit the shell with STATUS, even in a "trap 0" or "set -e" context. as_fn_exit () { set +e as_fn_set_status $1 exit $1 } # as_fn_exit # as_fn_mkdir_p # ------------- # Create "$as_dir" as a directory, including parents if necessary. as_fn_mkdir_p () { case $as_dir in #( -*) as_dir=./$as_dir;; esac test -d "$as_dir" || eval $as_mkdir_p || { as_dirs= while :; do case $as_dir in #( *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( *) as_qdir=$as_dir;; esac as_dirs="'$as_qdir' $as_dirs" as_dir=`$as_dirname -- "$as_dir" || $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` test -d "$as_dir" && break done test -z "$as_dirs" || eval "mkdir $as_dirs" } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" } # as_fn_mkdir_p # as_fn_executable_p FILE # ----------------------- # Test if FILE is an executable regular file. as_fn_executable_p () { test -f "$1" && test -x "$1" } # as_fn_executable_p # as_fn_append VAR VALUE # ---------------------- # Append the text in VALUE to the end of the definition contained in VAR. Take # advantage of any shell optimizations that allow amortized linear growth over # repeated appends, instead of the typical quadratic growth present in naive # implementations. if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : eval 'as_fn_append () { eval $1+=\$2 }' else as_fn_append () { eval $1=\$$1\$2 } fi # as_fn_append # as_fn_arith ARG... # ------------------ # Perform arithmetic evaluation on the ARGs, and store the result in the # global $as_val. Take advantage of shells that can avoid forks. The arguments # must be portable across $(()) and expr. if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : eval 'as_fn_arith () { as_val=$(( $* )) }' else as_fn_arith () { as_val=`expr "$@" || test $? -eq 1` } fi # as_fn_arith # as_fn_error STATUS ERROR [LINENO LOG_FD] # ---------------------------------------- # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are # provided, also output the error to LOG_FD, referencing LINENO. Then exit the # script with STATUS, using 1 if that was 0. as_fn_error () { as_status=$1; test $as_status -eq 0 && as_status=1 if test "$4"; then as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi $as_echo "$as_me: error: $2" >&2 as_fn_exit $as_status } # as_fn_error if expr a : '\(a\)' >/dev/null 2>&1 && test "X`expr 00001 : '.*\(...\)'`" = X001; then as_expr=expr else as_expr=false fi if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then as_basename=basename else as_basename=false fi if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then as_dirname=dirname else as_dirname=false fi as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || $as_echo X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q } /^X\/\(\/\/\)$/{ s//\1/ q } /^X\/\(\/\).*/{ s//\1/ q } s/.*/./; q'` # Avoid depending upon Character Ranges. as_cr_letters='abcdefghijklmnopqrstuvwxyz' as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' as_cr_Letters=$as_cr_letters$as_cr_LETTERS as_cr_digits='0123456789' as_cr_alnum=$as_cr_Letters$as_cr_digits as_lineno_1=$LINENO as_lineno_1a=$LINENO as_lineno_2=$LINENO as_lineno_2a=$LINENO eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" && test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || { # Blame Lee E. McMahon (1931-1989) for sed's syntax. :-) sed -n ' p /[$]LINENO/= ' <$as_myself | sed ' s/[$]LINENO.*/&-/ t lineno b :lineno N :loop s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/ t loop s/-\n.*// ' >$as_me.lineno && chmod +x "$as_me.lineno" || { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; } # If we had to re-execute with $CONFIG_SHELL, we're ensured to have # already done that, so ensure we don't try to do so again and fall # in an infinite loop. This has already happened in practice. _as_can_reexec=no; export _as_can_reexec # Don't try to exec as it changes $[0], causing all sort of problems # (the dirname of $[0] is not the place where we might find the # original and so on. Autoconf is especially sensitive to this). . "./$as_me.lineno" # Exit status is that of the last command. exit } ECHO_C= ECHO_N= ECHO_T= case `echo -n x` in #((((( -n*) case `echo 'xy\c'` in *c*) ECHO_T=' ';; # ECHO_T is single tab character. xy) ECHO_C='\c';; *) echo `echo ksh88 bug on AIX 6.1` > /dev/null ECHO_T=' ';; esac;; *) ECHO_N='-n';; esac rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file else rm -f conf$$.dir mkdir conf$$.dir 2>/dev/null fi if (echo >conf$$.file) 2>/dev/null; then if ln -s conf$$.file conf$$ 2>/dev/null; then as_ln_s='ln -s' # ... but there are two gotchas: # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. # In both cases, we have to default to `cp -pR'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || as_ln_s='cp -pR' elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else as_ln_s='cp -pR' fi else as_ln_s='cp -pR' fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null if mkdir -p . 2>/dev/null; then as_mkdir_p='mkdir -p "$as_dir"' else test -d ./-p && rmdir ./-p as_mkdir_p=false fi as_test_x='test -x' as_executable_p=as_fn_executable_p # Sed expression to map a string onto a valid CPP name. as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" # Sed expression to map a string onto a valid variable name. as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" SHELL=${CONFIG_SHELL-/bin/sh} test -n "$DJDIR" || exec 7<&0 &1 # Name of the host. # hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status, # so uname gets run too. ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q` # # Initializations. # ac_default_prefix=/usr/local ac_clean_files= ac_config_libobj_dir=. LIBOBJS= cross_compiling=no subdirs= MFLAGS= MAKEFLAGS= # Identity of this package. PACKAGE_NAME='mmdb' PACKAGE_TARNAME='mmdb' PACKAGE_VERSION='1.25.5' PACKAGE_STRING='mmdb 1.25.5' PACKAGE_BUGREPORT='' PACKAGE_URL='' ac_unique_file="mmdb/mmdb_align.cpp" # Factoring default headers for most tests. ac_includes_default="\ #include #ifdef HAVE_SYS_TYPES_H # include #endif #ifdef HAVE_SYS_STAT_H # include #endif #ifdef STDC_HEADERS # include # include #else # ifdef HAVE_STDLIB_H # include # endif #endif #ifdef HAVE_STRING_H # if !defined STDC_HEADERS && defined HAVE_MEMORY_H # include # endif # include #endif #ifdef HAVE_STRINGS_H # include #endif #ifdef HAVE_INTTYPES_H # include #endif #ifdef HAVE_STDINT_H # include #endif #ifdef HAVE_UNISTD_H # include #endif" ac_subst_vars='am__EXEEXT_FALSE am__EXEEXT_TRUE LTLIBOBJS LIBOBJS MAINT MAINTAINER_MODE_FALSE MAINTAINER_MODE_TRUE CXXCPP am__fastdepCXX_FALSE am__fastdepCXX_TRUE CXXDEPMODE ac_ct_CXX CXXFLAGS CXX CPP OTOOL64 OTOOL LIPO NMEDIT DSYMUTIL MANIFEST_TOOL RANLIB LN_S NM ac_ct_DUMPBIN DUMPBIN LD FGREP EGREP GREP SED host_os host_vendor host_cpu host build_os build_vendor build_cpu build LIBTOOL OBJDUMP DLLTOOL AS am__fastdepCC_FALSE am__fastdepCC_TRUE CCDEPMODE am__nodep AMDEPBACKSLASH AMDEP_FALSE AMDEP_TRUE am__quote am__include DEPDIR OBJEXT EXEEXT ac_ct_CC CPPFLAGS LDFLAGS CFLAGS CC ac_ct_AR AR AM_BACKSLASH AM_DEFAULT_VERBOSITY AM_DEFAULT_V AM_V am__untar am__tar AMTAR am__leading_dot SET_MAKE AWK mkdir_p MKDIR_P INSTALL_STRIP_PROGRAM STRIP install_sh MAKEINFO AUTOHEADER AUTOMAKE AUTOCONF ACLOCAL VERSION PACKAGE CYGPATH_W am__isrc INSTALL_DATA INSTALL_SCRIPT INSTALL_PROGRAM target_alias host_alias build_alias LIBS ECHO_T ECHO_N ECHO_C DEFS mandir localedir libdir psdir pdfdir dvidir htmldir infodir docdir oldincludedir includedir localstatedir sharedstatedir sysconfdir datadir datarootdir libexecdir sbindir bindir program_transform_name prefix exec_prefix PACKAGE_URL PACKAGE_BUGREPORT PACKAGE_STRING PACKAGE_VERSION PACKAGE_TARNAME PACKAGE_NAME PATH_SEPARATOR SHELL' ac_subst_files='' ac_user_opts=' enable_option_checking enable_silent_rules enable_dependency_tracking enable_shared enable_static with_pic enable_fast_install with_gnu_ld with_sysroot enable_libtool_lock enable_maintainer_mode ' ac_precious_vars='build_alias host_alias target_alias CC CFLAGS LDFLAGS LIBS CPPFLAGS CPP CXX CXXFLAGS CCC CXXCPP' # Initialize some variables set by options. ac_init_help= ac_init_version=false ac_unrecognized_opts= ac_unrecognized_sep= # The variables have the same names as the options, with # dashes changed to underlines. cache_file=/dev/null exec_prefix=NONE no_create= no_recursion= prefix=NONE program_prefix=NONE program_suffix=NONE program_transform_name=s,x,x, silent= site= srcdir= verbose= x_includes=NONE x_libraries=NONE # Installation directory options. # These are left unexpanded so users can "make install exec_prefix=/foo" # and all the variables that are supposed to be based on exec_prefix # by default will actually change. # Use braces instead of parens because sh, perl, etc. also accept them. # (The list follows the same order as the GNU Coding Standards.) bindir='${exec_prefix}/bin' sbindir='${exec_prefix}/sbin' libexecdir='${exec_prefix}/libexec' datarootdir='${prefix}/share' datadir='${datarootdir}' sysconfdir='${prefix}/etc' sharedstatedir='${prefix}/com' localstatedir='${prefix}/var' includedir='${prefix}/include' oldincludedir='/usr/include' docdir='${datarootdir}/doc/${PACKAGE_TARNAME}' infodir='${datarootdir}/info' htmldir='${docdir}' dvidir='${docdir}' pdfdir='${docdir}' psdir='${docdir}' libdir='${exec_prefix}/lib' localedir='${datarootdir}/locale' mandir='${datarootdir}/man' ac_prev= ac_dashdash= 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=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;; *=) ac_optarg= ;; *) ac_optarg=yes ;; esac # Accept the important Cygnus configure options, so we can diagnose typos. case $ac_dashdash$ac_option in --) ac_dashdash=yes ;; -bindir | --bindir | --bindi | --bind | --bin | --bi) ac_prev=bindir ;; -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) bindir=$ac_optarg ;; -build | --build | --buil | --bui | --bu) ac_prev=build_alias ;; -build=* | --build=* | --buil=* | --bui=* | --bu=*) build_alias=$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 ;; --config-cache | -C) cache_file=config.cache ;; -datadir | --datadir | --datadi | --datad) ac_prev=datadir ;; -datadir=* | --datadir=* | --datadi=* | --datad=*) datadir=$ac_optarg ;; -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \ | --dataroo | --dataro | --datar) ac_prev=datarootdir ;; -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \ | --dataroot=* | --dataroo=* | --dataro=* | --datar=*) datarootdir=$ac_optarg ;; -disable-* | --disable-*) ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid feature name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "enable_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval enable_$ac_useropt=no ;; -docdir | --docdir | --docdi | --doc | --do) ac_prev=docdir ;; -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*) docdir=$ac_optarg ;; -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv) ac_prev=dvidir ;; -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*) dvidir=$ac_optarg ;; -enable-* | --enable-*) ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid feature name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "enable_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval enable_$ac_useropt=\$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 | -h) ac_init_help=long ;; -help=r* | --help=r* | --hel=r* | --he=r* | -hr*) ac_init_help=recursive ;; -help=s* | --help=s* | --hel=s* | --he=s* | -hs*) ac_init_help=short ;; -host | --host | --hos | --ho) ac_prev=host_alias ;; -host=* | --host=* | --hos=* | --ho=*) host_alias=$ac_optarg ;; -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht) ac_prev=htmldir ;; -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \ | --ht=*) htmldir=$ac_optarg ;; -includedir | --includedir | --includedi | --included | --include \ | --includ | --inclu | --incl | --inc) ac_prev=includedir ;; -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ | --includ=* | --inclu=* | --incl=* | --inc=*) includedir=$ac_optarg ;; -infodir | --infodir | --infodi | --infod | --info | --inf) ac_prev=infodir ;; -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) infodir=$ac_optarg ;; -libdir | --libdir | --libdi | --libd) ac_prev=libdir ;; -libdir=* | --libdir=* | --libdi=* | --libd=*) libdir=$ac_optarg ;; -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ | --libexe | --libex | --libe) ac_prev=libexecdir ;; -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ | --libexe=* | --libex=* | --libe=*) libexecdir=$ac_optarg ;; -localedir | --localedir | --localedi | --localed | --locale) ac_prev=localedir ;; -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*) localedir=$ac_optarg ;; -localstatedir | --localstatedir | --localstatedi | --localstated \ | --localstate | --localstat | --localsta | --localst | --locals) ac_prev=localstatedir ;; -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*) localstatedir=$ac_optarg ;; -mandir | --mandir | --mandi | --mand | --man | --ma | --m) ac_prev=mandir ;; -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) mandir=$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 | -n) 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 ;; -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ | --oldin | --oldi | --old | --ol | --o) ac_prev=oldincludedir ;; -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) oldincludedir=$ac_optarg ;; -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 ;; -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd) ac_prev=pdfdir ;; -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*) pdfdir=$ac_optarg ;; -psdir | --psdir | --psdi | --psd | --ps) ac_prev=psdir ;; -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*) psdir=$ac_optarg ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil) silent=yes ;; -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) ac_prev=sbindir ;; -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ | --sbi=* | --sb=*) sbindir=$ac_optarg ;; -sharedstatedir | --sharedstatedir | --sharedstatedi \ | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ | --sharedst | --shareds | --shared | --share | --shar \ | --sha | --sh) ac_prev=sharedstatedir ;; -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ | --sha=* | --sh=*) sharedstatedir=$ac_optarg ;; -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 ;; -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ | --syscon | --sysco | --sysc | --sys | --sy) ac_prev=sysconfdir ;; -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) sysconfdir=$ac_optarg ;; -target | --target | --targe | --targ | --tar | --ta | --t) ac_prev=target_alias ;; -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) target_alias=$ac_optarg ;; -v | -verbose | --verbose | --verbos | --verbo | --verb) verbose=yes ;; -version | --version | --versio | --versi | --vers | -V) ac_init_version=: ;; -with-* | --with-*) ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid package name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "with_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval with_$ac_useropt=\$ac_optarg ;; -without-* | --without-*) ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid package name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "with_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval with_$ac_useropt=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 ;; -*) as_fn_error $? "unrecognized option: \`$ac_option' Try \`$0 --help' for more information" ;; *=*) ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='` # Reject names that are not valid shell variable names. case $ac_envvar in #( '' | [0-9]* | *[!_$as_cr_alnum]* ) as_fn_error $? "invalid variable name: \`$ac_envvar'" ;; esac eval $ac_envvar=\$ac_optarg export $ac_envvar ;; *) # FIXME: should be removed in autoconf 3.0. $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2 expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2 : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}" ;; esac done if test -n "$ac_prev"; then ac_option=--`echo $ac_prev | sed 's/_/-/g'` as_fn_error $? "missing argument to $ac_option" fi if test -n "$ac_unrecognized_opts"; then case $enable_option_checking in no) ;; fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;; *) $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;; esac fi # Check all directory arguments for consistency. for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \ datadir sysconfdir sharedstatedir localstatedir includedir \ oldincludedir docdir infodir htmldir dvidir pdfdir psdir \ libdir localedir mandir do eval ac_val=\$$ac_var # Remove trailing slashes. case $ac_val in */ ) ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'` eval $ac_var=\$ac_val;; esac # Be sure to have absolute directory names. case $ac_val in [\\/$]* | ?:[\\/]* ) continue;; NONE | '' ) case $ac_var in *prefix ) continue;; esac;; esac as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val" done # There might be people who depend on the old broken behavior: `$host' # used to hold the argument of --host etc. # FIXME: To remove some day. build=$build_alias host=$host_alias target=$target_alias # FIXME: To remove some day. if test "x$host_alias" != x; then if test "x$build_alias" = x; then cross_compiling=maybe elif test "x$build_alias" != "x$host_alias"; then cross_compiling=yes fi fi ac_tool_prefix= test -n "$host_alias" && ac_tool_prefix=$host_alias- test "$silent" = yes && exec 6>/dev/null ac_pwd=`pwd` && test -n "$ac_pwd" && ac_ls_di=`ls -di .` && ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` || as_fn_error $? "working directory cannot be determined" test "X$ac_ls_di" = "X$ac_pwd_ls_di" || as_fn_error $? "pwd does not report name of working directory" # 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 the parent directory. ac_confdir=`$as_dirname -- "$as_myself" || $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_myself" : 'X\(//\)[^/]' \| \ X"$as_myself" : 'X\(//\)$' \| \ X"$as_myself" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$as_myself" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` 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 test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .." as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir" fi ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work" ac_abs_confdir=`( cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg" pwd)` # When building in place, set srcdir=. if test "$ac_abs_confdir" = "$ac_pwd"; then srcdir=. fi # Remove unnecessary trailing slashes from srcdir. # Double slashes in file names in object file debugging info # mess up M-x gdb in Emacs. case $srcdir in */) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;; esac for ac_var in $ac_precious_vars; do eval ac_env_${ac_var}_set=\${${ac_var}+set} eval ac_env_${ac_var}_value=\$${ac_var} eval ac_cv_env_${ac_var}_set=\${${ac_var}+set} eval ac_cv_env_${ac_var}_value=\$${ac_var} done # # Report the --help message. # if test "$ac_init_help" = "long"; then # 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 <<_ACEOF \`configure' configures mmdb 1.25.5 to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... To assign environment variables (e.g., CC, CFLAGS...), specify them as VAR=VALUE. See below for descriptions of some of the useful variables. Defaults for the options are specified in brackets. Configuration: -h, --help display this help and exit --help=short display options specific to this package --help=recursive display the short help of all the included packages -V, --version display version information and exit -q, --quiet, --silent do not print \`checking ...' messages --cache-file=FILE cache test results in FILE [disabled] -C, --config-cache alias for \`--cache-file=config.cache' -n, --no-create do not create output files --srcdir=DIR find the sources in DIR [configure dir or \`..'] Installation directories: --prefix=PREFIX install architecture-independent files in PREFIX [$ac_default_prefix] --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX [PREFIX] By default, \`make install' will install all the files in \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify an installation prefix other than \`$ac_default_prefix' using \`--prefix', for instance \`--prefix=\$HOME'. For better control, use the options below. Fine tuning of the installation directories: --bindir=DIR user executables [EPREFIX/bin] --sbindir=DIR system admin executables [EPREFIX/sbin] --libexecdir=DIR program executables [EPREFIX/libexec] --sysconfdir=DIR read-only single-machine data [PREFIX/etc] --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] --localstatedir=DIR modifiable single-machine data [PREFIX/var] --libdir=DIR object code libraries [EPREFIX/lib] --includedir=DIR C header files [PREFIX/include] --oldincludedir=DIR C header files for non-gcc [/usr/include] --datarootdir=DIR read-only arch.-independent data root [PREFIX/share] --datadir=DIR read-only architecture-independent data [DATAROOTDIR] --infodir=DIR info documentation [DATAROOTDIR/info] --localedir=DIR locale-dependent data [DATAROOTDIR/locale] --mandir=DIR man documentation [DATAROOTDIR/man] --docdir=DIR documentation root [DATAROOTDIR/doc/mmdb] --htmldir=DIR html documentation [DOCDIR] --dvidir=DIR dvi documentation [DOCDIR] --pdfdir=DIR pdf documentation [DOCDIR] --psdir=DIR ps documentation [DOCDIR] _ACEOF cat <<\_ACEOF Program names: --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 System types: --build=BUILD configure for building on BUILD [guessed] --host=HOST cross-compile to build programs to run on HOST [BUILD] _ACEOF fi if test -n "$ac_init_help"; then case $ac_init_help in short | recursive ) echo "Configuration of mmdb 1.25.5:";; esac cat <<\_ACEOF Optional Features: --disable-option-checking ignore unrecognized --enable/--with options --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) --enable-FEATURE[=ARG] include FEATURE [ARG=yes] --enable-silent-rules less verbose build output (undo: "make V=1") --disable-silent-rules verbose build output (undo: "make V=0") --enable-dependency-tracking do not reject slow dependency extractors --disable-dependency-tracking speeds up one-time build --enable-shared[=PKGS] build shared libraries [default=no] --enable-static[=PKGS] build static libraries [default=yes] --enable-fast-install[=PKGS] optimize for fast installation [default=yes] --disable-libtool-lock avoid locking (might break parallel builds) --enable-maintainer-mode enable make rules and dependencies not useful (and sometimes confusing) to the casual installer Optional Packages: --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) --with-pic try to use only PIC/non-PIC objects [default=use both] --with-gnu-ld assume the C compiler uses GNU ld [default=no] --with-sysroot=DIR Search for dependent libraries within DIR (or the compiler's sysroot if not specified). Some influential environment variables: CC C compiler command CFLAGS C compiler flags LDFLAGS linker flags, e.g. -L if you have libraries in a nonstandard directory LIBS libraries to pass to the linker, e.g. -l CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I if you have headers in a nonstandard directory CPP C preprocessor CXX C++ compiler command CXXFLAGS C++ compiler flags CXXCPP C++ preprocessor Use these variables to override the choices made by `configure' or to help it to find libraries and programs with nonstandard names/locations. Report bugs to the package provider. _ACEOF ac_status=$? fi if test "$ac_init_help" = "recursive"; then # If there are subdirs, report their specific --help. for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue test -d "$ac_dir" || { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } || continue ac_builddir=. case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` # A ".." for each directory in $ac_dir_suffix. ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; esac ;; esac ac_abs_top_builddir=$ac_pwd ac_abs_builddir=$ac_pwd$ac_dir_suffix # for backward compatibility: ac_top_builddir=$ac_top_build_prefix case $srcdir in .) # We are building in place. ac_srcdir=. ac_top_srcdir=$ac_top_builddir_sub ac_abs_top_srcdir=$ac_pwd ;; [\\/]* | ?:[\\/]* ) # Absolute name. ac_srcdir=$srcdir$ac_dir_suffix; ac_top_srcdir=$srcdir ac_abs_top_srcdir=$srcdir ;; *) # Relative name. ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix ac_top_srcdir=$ac_top_build_prefix$srcdir ac_abs_top_srcdir=$ac_pwd/$srcdir ;; esac ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix cd "$ac_dir" || { ac_status=$?; continue; } # Check for guested configure. if test -f "$ac_srcdir/configure.gnu"; then echo && $SHELL "$ac_srcdir/configure.gnu" --help=recursive elif test -f "$ac_srcdir/configure"; then echo && $SHELL "$ac_srcdir/configure" --help=recursive else $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2 fi || ac_status=$? cd "$ac_pwd" || { ac_status=$?; break; } done fi test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF mmdb configure 1.25.5 generated by GNU Autoconf 2.69 Copyright (C) 2012 Free Software Foundation, Inc. This configure script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it. _ACEOF exit fi ## ------------------------ ## ## Autoconf initialization. ## ## ------------------------ ## # ac_fn_c_try_compile LINENO # -------------------------- # Try to compile conftest.$ac_ext, and return whether this succeeded. ac_fn_c_try_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack rm -f conftest.$ac_objext if { { ac_try="$ac_compile" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { test -z "$ac_c_werror_flag" || test ! -s conftest.err } && test -s conftest.$ac_objext; then : ac_retval=0 else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_compile # ac_fn_c_try_link LINENO # ----------------------- # Try to link conftest.$ac_ext, and return whether this succeeded. ac_fn_c_try_link () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack rm -f conftest.$ac_objext conftest$ac_exeext if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { test -z "$ac_c_werror_flag" || test ! -s conftest.err } && test -s conftest$ac_exeext && { test "$cross_compiling" = yes || test -x conftest$ac_exeext }; then : ac_retval=0 else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would # interfere with the next link command; also delete a directory that is # left behind by Apple's compiler. We do this before executing the actions. rm -rf conftest.dSYM conftest_ipa8_conftest.oo eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_link # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES # ------------------------------------------------------- # Tests whether HEADER exists and can be compiled using the include files in # INCLUDES, setting the cache variable VAR accordingly. ac_fn_c_check_header_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 #include <$2> _ACEOF if ac_fn_c_try_compile "$LINENO"; then : eval "$3=yes" else eval "$3=no" fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_header_compile # ac_fn_c_try_cpp LINENO # ---------------------- # Try to preprocess conftest.$ac_ext, and return whether this succeeded. ac_fn_c_try_cpp () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if { { ac_try="$ac_cpp conftest.$ac_ext" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } > conftest.i && { test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || test ! -s conftest.err }; then : ac_retval=0 else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_cpp # ac_fn_c_try_run LINENO # ---------------------- # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes # that executables *can* be run. ac_fn_c_try_run () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { ac_try='./conftest$ac_exeext' { { case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_try") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; }; then : ac_retval=0 else $as_echo "$as_me: program exited with status $ac_status" >&5 $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=$ac_status fi rm -rf conftest.dSYM conftest_ipa8_conftest.oo eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_run # ac_fn_c_check_func LINENO FUNC VAR # ---------------------------------- # Tests whether FUNC exists, setting the cache variable VAR accordingly ac_fn_c_check_func () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Define $2 to an innocuous variant, in case declares $2. For example, HP-UX 11i declares gettimeofday. */ #define $2 innocuous_$2 /* System header to define __stub macros and hopefully few prototypes, which can conflict with char $2 (); below. Prefer to if __STDC__ is defined, since exists even on freestanding compilers. */ #ifdef __STDC__ # include #else # include #endif #undef $2 /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ #ifdef __cplusplus extern "C" #endif char $2 (); /* 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_$2 || defined __stub___$2 choke me #endif int main () { return $2 (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : eval "$3=yes" else eval "$3=no" fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_func # ac_fn_cxx_try_compile LINENO # ---------------------------- # Try to compile conftest.$ac_ext, and return whether this succeeded. ac_fn_cxx_try_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack rm -f conftest.$ac_objext if { { ac_try="$ac_compile" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { test -z "$ac_cxx_werror_flag" || test ! -s conftest.err } && test -s conftest.$ac_objext; then : ac_retval=0 else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_cxx_try_compile # ac_fn_cxx_try_cpp LINENO # ------------------------ # Try to preprocess conftest.$ac_ext, and return whether this succeeded. ac_fn_cxx_try_cpp () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if { { ac_try="$ac_cpp conftest.$ac_ext" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } > conftest.i && { test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" || test ! -s conftest.err }; then : ac_retval=0 else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_cxx_try_cpp # ac_fn_cxx_try_link LINENO # ------------------------- # Try to link conftest.$ac_ext, and return whether this succeeded. ac_fn_cxx_try_link () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack rm -f conftest.$ac_objext conftest$ac_exeext if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { test -z "$ac_cxx_werror_flag" || test ! -s conftest.err } && test -s conftest$ac_exeext && { test "$cross_compiling" = yes || test -x conftest$ac_exeext }; then : ac_retval=0 else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would # interfere with the next link command; also delete a directory that is # left behind by Apple's compiler. We do this before executing the actions. rm -rf conftest.dSYM conftest_ipa8_conftest.oo eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_cxx_try_link cat >config.log <<_ACEOF This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. It was created by mmdb $as_me 1.25.5, which was generated by GNU Autoconf 2.69. Invocation command line was $ $0 $@ _ACEOF exec 5>>config.log { cat <<_ASUNAME ## --------- ## ## Platform. ## ## --------- ## hostname = `(hostname || uname -n) 2>/dev/null | sed 1q` uname -m = `(uname -m) 2>/dev/null || echo unknown` uname -r = `(uname -r) 2>/dev/null || echo unknown` uname -s = `(uname -s) 2>/dev/null || echo unknown` uname -v = `(uname -v) 2>/dev/null || echo unknown` /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown` /bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown` /bin/arch = `(/bin/arch) 2>/dev/null || echo unknown` /usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown` /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown` /usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown` /bin/machine = `(/bin/machine) 2>/dev/null || echo unknown` /usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown` /bin/universe = `(/bin/universe) 2>/dev/null || echo unknown` _ASUNAME as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. $as_echo "PATH: $as_dir" done IFS=$as_save_IFS } >&5 cat >&5 <<_ACEOF ## ----------- ## ## Core tests. ## ## ----------- ## _ACEOF # Keep a trace of the command line. # Strip out --no-create and --no-recursion so they do not pile up. # Strip out --silent because we don't want to record it for future runs. # Also quote any args containing shell meta-characters. # Make two passes to allow for proper duplicate-argument suppression. ac_configure_args= ac_configure_args0= ac_configure_args1= ac_must_keep_next=false for ac_pass in 1 2 do for ac_arg do case $ac_arg in -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil) continue ;; *\'*) ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; esac case $ac_pass in 1) as_fn_append ac_configure_args0 " '$ac_arg'" ;; 2) as_fn_append ac_configure_args1 " '$ac_arg'" if test $ac_must_keep_next = true; then ac_must_keep_next=false # Got value, back to normal. else case $ac_arg in *=* | --config-cache | -C | -disable-* | --disable-* \ | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \ | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \ | -with-* | --with-* | -without-* | --without-* | --x) case "$ac_configure_args0 " in "$ac_configure_args1"*" '$ac_arg' "* ) continue ;; esac ;; -* ) ac_must_keep_next=true ;; esac fi as_fn_append ac_configure_args " '$ac_arg'" ;; esac done done { ac_configure_args0=; unset ac_configure_args0;} { ac_configure_args1=; unset ac_configure_args1;} # When interrupted or exit'd, cleanup temporary files, and complete # config.log. We remove comments because anyway the quotes in there # would cause problems or look ugly. # WARNING: Use '\'' to represent an apostrophe within the trap. # WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug. trap 'exit_status=$? # Save into config.log some information that might help in debugging. { echo $as_echo "## ---------------- ## ## Cache variables. ## ## ---------------- ##" echo # The following way of writing the cache mishandles newlines in values, ( for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do eval ac_val=\$$ac_var case $ac_val in #( *${as_nl}*) case $ac_var in #( *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( *) { eval $ac_var=; unset $ac_var;} ;; esac ;; esac done (set) 2>&1 | case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #( *${as_nl}ac_space=\ *) sed -n \ "s/'\''/'\''\\\\'\'''\''/g; s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p" ;; #( *) sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" ;; esac | sort ) echo $as_echo "## ----------------- ## ## Output variables. ## ## ----------------- ##" echo for ac_var in $ac_subst_vars do eval ac_val=\$$ac_var case $ac_val in *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; esac $as_echo "$ac_var='\''$ac_val'\''" done | sort echo if test -n "$ac_subst_files"; then $as_echo "## ------------------- ## ## File substitutions. ## ## ------------------- ##" echo for ac_var in $ac_subst_files do eval ac_val=\$$ac_var case $ac_val in *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; esac $as_echo "$ac_var='\''$ac_val'\''" done | sort echo fi if test -s confdefs.h; then $as_echo "## ----------- ## ## confdefs.h. ## ## ----------- ##" echo cat confdefs.h echo fi test "$ac_signal" != 0 && $as_echo "$as_me: caught signal $ac_signal" $as_echo "$as_me: exit $exit_status" } >&5 rm -f core *.core core.conftest.* && rm -f -r conftest* confdefs* conf$$* $ac_clean_files && exit $exit_status ' 0 for ac_signal in 1 2 13 15; do trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal done ac_signal=0 # confdefs.h avoids OS command line length limits that DEFS can exceed. rm -f -r conftest* confdefs.h $as_echo "/* confdefs.h */" > confdefs.h # Predefined preprocessor variables. cat >>confdefs.h <<_ACEOF #define PACKAGE_NAME "$PACKAGE_NAME" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_TARNAME "$PACKAGE_TARNAME" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_VERSION "$PACKAGE_VERSION" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_STRING "$PACKAGE_STRING" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_URL "$PACKAGE_URL" _ACEOF # Let the site file select an alternate cache file if it wants to. # Prefer an explicitly selected file to automatically selected ones. ac_site_file1=NONE ac_site_file2=NONE if test -n "$CONFIG_SITE"; then # We do not want a PATH search for config.site. case $CONFIG_SITE in #(( -*) ac_site_file1=./$CONFIG_SITE;; */*) ac_site_file1=$CONFIG_SITE;; *) ac_site_file1=./$CONFIG_SITE;; esac elif test "x$prefix" != xNONE; then ac_site_file1=$prefix/share/config.site ac_site_file2=$prefix/etc/config.site else ac_site_file1=$ac_default_prefix/share/config.site ac_site_file2=$ac_default_prefix/etc/config.site fi for ac_site_file in "$ac_site_file1" "$ac_site_file2" do test "x$ac_site_file" = xNONE && continue if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5 $as_echo "$as_me: loading site script $ac_site_file" >&6;} sed 's/^/| /' "$ac_site_file" >&5 . "$ac_site_file" \ || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "failed to load site script $ac_site_file See \`config.log' for more details" "$LINENO" 5; } fi done if test -r "$cache_file"; then # Some versions of bash will fail to source /dev/null (special files # actually), so we avoid doing that. DJGPP emulates it as a regular file. if test /dev/null != "$cache_file" && test -f "$cache_file"; then { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5 $as_echo "$as_me: loading cache $cache_file" >&6;} case $cache_file in [\\/]* | ?:[\\/]* ) . "$cache_file";; *) . "./$cache_file";; esac fi else { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5 $as_echo "$as_me: creating cache $cache_file" >&6;} >$cache_file fi # Check that the precious variables saved in the cache have kept the same # value. ac_cache_corrupted=false for ac_var in $ac_precious_vars; do eval ac_old_set=\$ac_cv_env_${ac_var}_set eval ac_new_set=\$ac_env_${ac_var}_set eval ac_old_val=\$ac_cv_env_${ac_var}_value eval ac_new_val=\$ac_env_${ac_var}_value case $ac_old_set,$ac_new_set in set,) { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 $as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} ac_cache_corrupted=: ;; ,set) { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5 $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;} ac_cache_corrupted=: ;; ,);; *) if test "x$ac_old_val" != "x$ac_new_val"; then # differences in whitespace do not lead to failure. ac_old_val_w=`echo x $ac_old_val` ac_new_val_w=`echo x $ac_new_val` if test "$ac_old_val_w" != "$ac_new_val_w"; then { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5 $as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} ac_cache_corrupted=: else { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5 $as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;} eval $ac_var=\$ac_old_val fi { $as_echo "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5 $as_echo "$as_me: former value: \`$ac_old_val'" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5 $as_echo "$as_me: current value: \`$ac_new_val'" >&2;} fi;; esac # Pass precious variables to config.status. if test "$ac_new_set" = set; then case $ac_new_val in *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; *) ac_arg=$ac_var=$ac_new_val ;; esac case " $ac_configure_args " in *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. *) as_fn_append ac_configure_args " '$ac_arg'" ;; esac fi done if $ac_cache_corrupted; then { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5 $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;} as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5 fi ## -------------------- ## ## Main body of script. ## ## -------------------- ## ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu # keep in sync with mmdb/mmdb_defs.h ac_aux_dir= for ac_dir in build-aux "$srcdir"/build-aux; 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 elif test -f "$ac_dir/shtool"; then ac_aux_dir=$ac_dir ac_install_sh="$ac_aux_dir/shtool install -c" break fi done if test -z "$ac_aux_dir"; then as_fn_error $? "cannot find install-sh, install.sh, or shtool in build-aux \"$srcdir\"/build-aux" "$LINENO" 5 fi # These three variables are undocumented and unsupported, # and are intended to be withdrawn in a future Autoconf release. # They can cause serious problems if a builder's source tree is in a directory # whose full name contains unusual characters. ac_config_guess="$SHELL $ac_aux_dir/config.guess" # Please don't use this var. ac_config_sub="$SHELL $ac_aux_dir/config.sub" # Please don't use this var. ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var. ac_config_headers="$ac_config_headers config.h" am__api_version='1.12' # 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 # AmigaOS /C/install, which installs bootblocks on floppy discs # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag # AFS /usr/afsws/bin/install, which mishandles nonexistent args # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff" # OS/2's system install, which has a completely different semantic # ./install, which can be erroneously created by make from ./install.sh. # Reject install programs that cannot install multiple files. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5 $as_echo_n "checking for a BSD-compatible install... " >&6; } if test -z "$INSTALL"; then if ${ac_cv_path_install+:} false; then : $as_echo_n "(cached) " >&6 else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. # Account for people who put trailing slashes in PATH elements. case $as_dir/ in #(( ./ | .// | /[cC]/* | \ /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \ ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \ /usr/ucb/* ) ;; *) # OSF1 and SCO ODT 3.0 have their own names for install. # Don't use installbsd from OSF since it installs stuff as root # by default. for ac_prog in ginstall scoinst install; do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then if test $ac_prog = install && grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then # AIX install. It has an incompatible calling convention. : elif test $ac_prog = install && grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then # program-specific install script used by HP pwplus--don't use. : else rm -rf conftest.one conftest.two conftest.dir echo one > conftest.one echo two > conftest.two mkdir conftest.dir if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" && test -s conftest.one && test -s conftest.two && test -s conftest.dir/conftest.one && test -s conftest.dir/conftest.two then ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c" break 3 fi fi fi done done ;; esac done IFS=$as_save_IFS rm -rf conftest.one conftest.two conftest.dir fi if test "${ac_cv_path_install+set}" = set; then INSTALL=$ac_cv_path_install else # As a last resort, use the slow shell script. Don't cache a # value for INSTALL within a source directory, because that will # break other packages using the cache if that directory is # removed, or if the value is a relative name. INSTALL=$ac_install_sh fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5 $as_echo "$INSTALL" >&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_SCRIPT" && INSTALL_SCRIPT='${INSTALL}' test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5 $as_echo_n "checking whether build environment is sane... " >&6; } # Reject unsafe characters in $srcdir or the absolute working directory # name. Accept space and tab only in the latter. am_lf=' ' case `pwd` in *[\\\"\#\$\&\'\`$am_lf]*) as_fn_error $? "unsafe absolute working directory name" "$LINENO" 5;; esac case $srcdir in *[\\\"\#\$\&\'\`$am_lf\ \ ]*) as_fn_error $? "unsafe srcdir value: '$srcdir'" "$LINENO" 5;; esac # Do 'set' in a subshell so we don't clobber the current shell's # arguments. Must try -L first in case configure is actually a # symlink; some systems play weird games with the mod time of symlinks # (eg FreeBSD returns the mod time of the symlink's containing # directory). if ( am_has_slept=no for am_try in 1 2; do echo "timestamp, slept: $am_has_slept" > conftest.file set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null` if test "$*" = "X"; then # -L didn't work. set X `ls -t "$srcdir/configure" conftest.file` fi if test "$*" != "X $srcdir/configure conftest.file" \ && test "$*" != "X conftest.file $srcdir/configure"; then # If neither matched, then we have a broken ls. This can happen # if, for instance, CONFIG_SHELL is bash and it inherits a # broken ls alias from the environment. This has actually # happened. Such a system could not be considered "sane". as_fn_error $? "ls -t appears to fail. Make sure there is not a broken alias in your environment" "$LINENO" 5 fi if test "$2" = conftest.file || test $am_try -eq 2; then break fi # Just in case. sleep 1 am_has_slept=yes done test "$2" = conftest.file ) then # Ok. : else as_fn_error $? "newly created file is older than distributed files! Check your system clock" "$LINENO" 5 fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } # If we didn't sleep, we still need to ensure time stamps of config.status and # generated files are strictly newer. am_sleep_pid= if grep 'slept: no' conftest.file >/dev/null 2>&1; then ( sleep 1 ) & am_sleep_pid=$! fi rm -f conftest.file 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" # Double any \ or $. # By default was `s,x,x', remove it if useless. ac_script='s/[\\$]/&&/g;s/;s,x,x,$//' program_transform_name=`$as_echo "$program_transform_name" | sed "$ac_script"` # expand $ac_aux_dir to an absolute path am_aux_dir=`cd $ac_aux_dir && pwd` if test x"${MISSING+set}" != xset; then case $am_aux_dir in *\ * | *\ *) MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;; *) MISSING="\${SHELL} $am_aux_dir/missing" ;; esac fi # Use eval to expand $SHELL if eval "$MISSING --run true"; then am_missing_run="$MISSING --run " else am_missing_run= { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: 'missing' script is too old or missing" >&5 $as_echo "$as_me: WARNING: 'missing' script is too old or missing" >&2;} fi if test x"${install_sh}" != xset; then case $am_aux_dir in *\ * | *\ *) install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;; *) install_sh="\${SHELL} $am_aux_dir/install-sh" esac fi # Installed binaries are usually stripped using 'strip' when the user # run "make install-strip". However 'strip' might not be the right # tool to use in cross-compilation environments, therefore Automake # will honor the 'STRIP' environment variable to overrule this program. if test "$cross_compiling" != no; then if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args. set dummy ${ac_tool_prefix}strip; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_STRIP+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$STRIP"; then ac_cv_prog_STRIP="$STRIP" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_STRIP="${ac_tool_prefix}strip" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi STRIP=$ac_cv_prog_STRIP if test -n "$STRIP"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5 $as_echo "$STRIP" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$ac_cv_prog_STRIP"; then ac_ct_STRIP=$STRIP # Extract the first word of "strip", so it can be a program name with args. set dummy strip; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_STRIP+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_STRIP"; then ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_STRIP="strip" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP if test -n "$ac_ct_STRIP"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5 $as_echo "$ac_ct_STRIP" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test "x$ac_ct_STRIP" = x; then STRIP=":" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac STRIP=$ac_ct_STRIP fi else STRIP="$ac_cv_prog_STRIP" fi fi INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s" { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a thread-safe mkdir -p" >&5 $as_echo_n "checking for a thread-safe mkdir -p... " >&6; } if test -z "$MKDIR_P"; then if ${ac_cv_path_mkdir+:} false; then : $as_echo_n "(cached) " >&6 else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH$PATH_SEPARATOR/opt/sfw/bin do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_prog in mkdir gmkdir; do for ac_exec_ext in '' $ac_executable_extensions; do as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext" || continue case `"$as_dir/$ac_prog$ac_exec_ext" --version 2>&1` in #( 'mkdir (GNU coreutils) '* | \ 'mkdir (coreutils) '* | \ 'mkdir (fileutils) '4.1*) ac_cv_path_mkdir=$as_dir/$ac_prog$ac_exec_ext break 3;; esac done done done IFS=$as_save_IFS fi test -d ./--version && rmdir ./--version if test "${ac_cv_path_mkdir+set}" = set; then MKDIR_P="$ac_cv_path_mkdir -p" else # As a last resort, use the slow shell script. Don't cache a # value for MKDIR_P within a source directory, because that will # break other packages using the cache if that directory is # removed, or if the value is a relative name. MKDIR_P="$ac_install_sh -d" fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5 $as_echo "$MKDIR_P" >&6; } for ac_prog in gawk mawk nawk awk do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_AWK+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$AWK"; then ac_cv_prog_AWK="$AWK" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_AWK="$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi AWK=$ac_cv_prog_AWK if test -n "$AWK"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5 $as_echo "$AWK" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$AWK" && break done { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5 $as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; } set x ${MAKE-make} ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'` if eval \${ac_cv_prog_make_${ac_make}_set+:} false; then : $as_echo_n "(cached) " >&6 else cat >conftest.make <<\_ACEOF SHELL = /bin/sh all: @echo '@@@%%%=$(MAKE)=@@@%%%' _ACEOF # GNU make sometimes prints "make[1]: Entering ...", which would confuse us. case `${MAKE-make} -f conftest.make 2>/dev/null` in *@@@%%%=?*=@@@%%%*) eval ac_cv_prog_make_${ac_make}_set=yes;; *) eval ac_cv_prog_make_${ac_make}_set=no;; esac rm -f conftest.make fi if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } SET_MAKE= else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } SET_MAKE="MAKE=${MAKE-make}" fi rm -rf .tst 2>/dev/null mkdir .tst 2>/dev/null if test -d .tst; then am__leading_dot=. else am__leading_dot=_ fi rmdir .tst 2>/dev/null # Check whether --enable-silent-rules was given. if test "${enable_silent_rules+set}" = set; then : enableval=$enable_silent_rules; fi case $enable_silent_rules in # ((( yes) AM_DEFAULT_VERBOSITY=0;; no) AM_DEFAULT_VERBOSITY=1;; *) AM_DEFAULT_VERBOSITY=1;; esac am_make=${MAKE-make} { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $am_make supports nested variables" >&5 $as_echo_n "checking whether $am_make supports nested variables... " >&6; } if ${am_cv_make_support_nested_variables+:} false; then : $as_echo_n "(cached) " >&6 else if $as_echo 'TRUE=$(BAR$(V)) BAR0=false BAR1=true V=1 am__doit: @$(TRUE) .PHONY: am__doit' | $am_make -f - >/dev/null 2>&1; then am_cv_make_support_nested_variables=yes else am_cv_make_support_nested_variables=no fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_make_support_nested_variables" >&5 $as_echo "$am_cv_make_support_nested_variables" >&6; } if test $am_cv_make_support_nested_variables = yes; then AM_V='$(V)' AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)' else AM_V=$AM_DEFAULT_VERBOSITY AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY fi AM_BACKSLASH='\' if test "`cd $srcdir && pwd`" != "`pwd`"; then # Use -I$(srcdir) only when $(srcdir) != ., so that make's output # is not polluted with repeated "-I." am__isrc=' -I$(srcdir)' # test to see if srcdir already configured if test -f $srcdir/config.status; then as_fn_error $? "source directory already configured; run \"make distclean\" there first" "$LINENO" 5 fi fi # test whether we have cygpath if test -z "$CYGPATH_W"; then if (cygpath --version) >/dev/null 2>/dev/null; then CYGPATH_W='cygpath -w' else CYGPATH_W=echo fi fi # Define the identity of the package. PACKAGE='mmdb' VERSION='1.25.5' cat >>confdefs.h <<_ACEOF #define PACKAGE "$PACKAGE" _ACEOF cat >>confdefs.h <<_ACEOF #define VERSION "$VERSION" _ACEOF # Some tools Automake needs. ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"} AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"} AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"} AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"} MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"} # For better backward compatibility. To be removed once Automake 1.9.x # dies out for good. For more background, see: # # mkdir_p='$(MKDIR_P)' # We need awk for the "check" target. The system "awk" is bad on # some platforms. # Always define AMTAR for backward compatibility. Yes, it's still used # in the wild :-( We should find a proper way to deprecate it ... AMTAR='$${TAR-tar}' am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -' DEPDIR="${am__leading_dot}deps" ac_config_commands="$ac_config_commands depfiles" am_make=${MAKE-make} cat > confinc << 'END' am__doit: @echo this is the am__doit target .PHONY: am__doit END # If we don't find an include directive, just comment out the code. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for style of include used by $am_make" >&5 $as_echo_n "checking for style of include used by $am_make... " >&6; } am__include="#" am__quote= _am_result=none # First try GNU make style include. echo "include confinc" > confmf # Ignore all kinds of additional output from 'make'. case `$am_make -s -f confmf 2> /dev/null` in #( *the\ am__doit\ target*) am__include=include am__quote= _am_result=GNU ;; esac # Now try BSD make style include. if test "$am__include" = "#"; then echo '.include "confinc"' > confmf case `$am_make -s -f confmf 2> /dev/null` in #( *the\ am__doit\ target*) am__include=.include am__quote="\"" _am_result=BSD ;; esac fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_am_result" >&5 $as_echo "$_am_result" >&6; } rm -f confinc confmf # Check whether --enable-dependency-tracking was given. if test "${enable_dependency_tracking+set}" = set; then : enableval=$enable_dependency_tracking; fi if test "x$enable_dependency_tracking" != xno; then am_depcomp="$ac_aux_dir/depcomp" AMDEPBACKSLASH='\' am__nodep='_no' fi if test "x$enable_dependency_tracking" != xno; then AMDEP_TRUE= AMDEP_FALSE='#' else AMDEP_TRUE='#' AMDEP_FALSE= fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args. set dummy ${ac_tool_prefix}gcc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_CC="${ac_tool_prefix}gcc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$ac_cv_prog_CC"; then ac_ct_CC=$CC # Extract the first word of "gcc", so it can be a program name with args. set dummy gcc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CC="gcc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 $as_echo "$ac_ct_CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test "x$ac_ct_CC" = x; then CC="" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi else CC="$ac_cv_prog_CC" fi if test -z "$CC"; then if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args. set dummy ${ac_tool_prefix}cc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_CC="${ac_tool_prefix}cc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi fi if test -z "$CC"; then # Extract the first word of "cc", so it can be a program name with args. set dummy cc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else ac_prog_rejected=no as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then ac_prog_rejected=yes continue fi ac_cv_prog_CC="cc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS if test $ac_prog_rejected = yes; then # We found a bogon in the path, so make sure we never use it. set dummy $ac_cv_prog_CC shift if test $# != 0; then # We chose a different compiler from the bogus one. # However, it has the same basename, so the bogon will be chosen # first if we set CC to just the basename; use the full file name. shift ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@" fi fi fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$CC"; then if test -n "$ac_tool_prefix"; then for ac_prog in cl.exe do # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. set dummy $ac_tool_prefix$ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_CC="$ac_tool_prefix$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$CC" && break done fi if test -z "$CC"; then ac_ct_CC=$CC for ac_prog in cl.exe do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CC="$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 $as_echo "$ac_ct_CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$ac_ct_CC" && break done if test "x$ac_ct_CC" = x; then CC="" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi fi fi test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "no acceptable C compiler found in \$PATH See \`config.log' for more details" "$LINENO" 5; } # Provide some information about the compiler. $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 set X $ac_compile ac_compiler=$2 for ac_option in --version -v -V -qversion; do { { ac_try="$ac_compiler $ac_option >&5" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compiler $ac_option >&5") 2>conftest.err ac_status=$? if test -s conftest.err; then sed '10a\ ... rest of stderr output deleted ... 10q' conftest.err >conftest.er1 cat conftest.er1 >&5 fi rm -f conftest.er1 conftest.err $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } done cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF ac_clean_files_save=$ac_clean_files ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out" # Try to create an executable without -o first, disregard a.out. # It will help us diagnose broken compilers, and finding out an intuition # of exeext. { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5 $as_echo_n "checking whether the C compiler works... " >&6; } ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'` # The possible output files: ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*" ac_rmfiles= for ac_file in $ac_files do case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; * ) ac_rmfiles="$ac_rmfiles $ac_file";; esac done rm -f $ac_rmfiles if { { ac_try="$ac_link_default" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link_default") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then : # Autoconf-2.13 could set the ac_cv_exeext variable to `no'. # So ignore a value of `no', otherwise this would lead to `EXEEXT = no' # in a Makefile. We should not override ac_cv_exeext if it was cached, # so that the user can short-circuit this test for compilers unknown to # Autoconf. for ac_file in $ac_files '' do test -f "$ac_file" || continue case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; [ab].out ) # We found the default executable, but exeext='' is most # certainly right. break;; *.* ) if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no; then :; else ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` fi # We set ac_cv_exeext here because the later test for it is not # safe: cross compilers may not add the suffix if given an `-o' # argument, so we may need to know it at that point already. # Even if this section looks crufty: it has the advantage of # actually working. break;; * ) break;; esac done test "$ac_cv_exeext" = no && ac_cv_exeext= else ac_file='' fi if test -z "$ac_file"; then : { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error 77 "C compiler cannot create executables See \`config.log' for more details" "$LINENO" 5; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5 $as_echo_n "checking for C compiler default output file name... " >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5 $as_echo "$ac_file" >&6; } ac_exeext=$ac_cv_exeext rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out ac_clean_files=$ac_clean_files_save { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5 $as_echo_n "checking for suffix of executables... " >&6; } if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then : # If both `conftest.exe' and `conftest' are `present' (well, observable) # catch `conftest.exe'. For instance with Cygwin, `ls conftest' will # work properly (i.e., refer to `conftest.exe'), while it won't with # `rm'. for ac_file in conftest.exe conftest conftest.*; do test -f "$ac_file" || continue case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` break;; * ) break;; esac done else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of executables: cannot compile and link See \`config.log' for more details" "$LINENO" 5; } fi rm -f conftest conftest$ac_cv_exeext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5 $as_echo "$ac_cv_exeext" >&6; } rm -f conftest.$ac_ext EXEEXT=$ac_cv_exeext ac_exeext=$EXEEXT cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main () { FILE *f = fopen ("conftest.out", "w"); return ferror (f) || fclose (f) != 0; ; return 0; } _ACEOF ac_clean_files="$ac_clean_files conftest.out" # Check that the compiler produces executables we can run. If not, either # the compiler is broken, or we cross compile. { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5 $as_echo_n "checking whether we are cross compiling... " >&6; } if test "$cross_compiling" != yes; then { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } if { ac_try='./conftest$ac_cv_exeext' { { case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_try") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; }; then cross_compiling=no else if test "$cross_compiling" = maybe; then cross_compiling=yes else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot run C compiled programs. If you meant to cross compile, use \`--host'. See \`config.log' for more details" "$LINENO" 5; } fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5 $as_echo "$cross_compiling" >&6; } rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out ac_clean_files=$ac_clean_files_save { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5 $as_echo_n "checking for suffix of object files... " >&6; } if ${ac_cv_objext+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF rm -f conftest.o conftest.obj if { { ac_try="$ac_compile" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then : for ac_file in conftest.o conftest.obj conftest.*; do test -f "$ac_file" || continue; case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;; *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` break;; esac done else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of object files: cannot compile See \`config.log' for more details" "$LINENO" 5; } fi rm -f conftest.$ac_cv_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5 $as_echo "$ac_cv_objext" >&6; } OBJEXT=$ac_cv_objext ac_objext=$OBJEXT { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5 $as_echo_n "checking whether we are using the GNU C compiler... " >&6; } if ${ac_cv_c_compiler_gnu+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { #ifndef __GNUC__ choke me #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_compiler_gnu=yes else ac_compiler_gnu=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_cv_c_compiler_gnu=$ac_compiler_gnu fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 $as_echo "$ac_cv_c_compiler_gnu" >&6; } if test $ac_compiler_gnu = yes; then GCC=yes else GCC= fi ac_test_CFLAGS=${CFLAGS+set} ac_save_CFLAGS=$CFLAGS { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 $as_echo_n "checking whether $CC accepts -g... " >&6; } if ${ac_cv_prog_cc_g+:} false; then : $as_echo_n "(cached) " >&6 else ac_save_c_werror_flag=$ac_c_werror_flag ac_c_werror_flag=yes ac_cv_prog_cc_g=no CFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_g=yes else CFLAGS="" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : else ac_c_werror_flag=$ac_save_c_werror_flag CFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_g=yes fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_c_werror_flag=$ac_save_c_werror_flag fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 $as_echo "$ac_cv_prog_cc_g" >&6; } if test "$ac_test_CFLAGS" = set; then CFLAGS=$ac_save_CFLAGS elif test $ac_cv_prog_cc_g = yes; then if test "$GCC" = yes; then CFLAGS="-g -O2" else CFLAGS="-g" fi else if test "$GCC" = yes; then CFLAGS="-O2" else CFLAGS= fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5 $as_echo_n "checking for $CC option to accept ISO C89... " >&6; } if ${ac_cv_prog_cc_c89+:} false; then : $as_echo_n "(cached) " >&6 else ac_cv_prog_cc_c89=no ac_save_CC=$CC cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include struct stat; /* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ struct buf { int x; }; FILE * (*rcsopen) (struct buf *, struct stat *, int); static char *e (p, i) char **p; int i; { return p[i]; } static char *f (char * (*g) (char **, int), char **p, ...) { char *s; va_list v; va_start (v,p); s = g (p, va_arg (v,int)); va_end (v); return s; } /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has function prototypes and stuff, but not '\xHH' hex character constants. These don't provoke an error unfortunately, instead are silently treated as 'x'. The following induces an error, until -std is added to get proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an array size at least. It's necessary to write '\x00'==0 to get something that's true only with -std. */ int osf4_cc_array ['\x00' == 0 ? 1 : -1]; /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters inside strings and character constants. */ #define FOO(x) 'x' int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1]; int test (int i, double x); struct s1 {int (*f) (int a);}; struct s2 {int (*f) (double a);}; int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); int argc; char **argv; int main () { return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; ; return 0; } _ACEOF for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \ -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" do CC="$ac_save_CC $ac_arg" if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_c89=$ac_arg fi rm -f core conftest.err conftest.$ac_objext test "x$ac_cv_prog_cc_c89" != "xno" && break done rm -f conftest.$ac_ext CC=$ac_save_CC fi # AC_CACHE_VAL case "x$ac_cv_prog_cc_c89" in x) { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 $as_echo "none needed" >&6; } ;; xno) { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 $as_echo "unsupported" >&6; } ;; *) CC="$CC $ac_cv_prog_cc_c89" { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 $as_echo "$ac_cv_prog_cc_c89" >&6; } ;; esac if test "x$ac_cv_prog_cc_c89" != xno; then : fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu depcc="$CC" am_compiler_list= { $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5 $as_echo_n "checking dependency style of $depcc... " >&6; } if ${am_cv_CC_dependencies_compiler_type+:} false; then : $as_echo_n "(cached) " >&6 else if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then # We make a subdir and do the tests there. Otherwise we can end up # making bogus files that we don't know about and never remove. For # instance it was reported that on HP-UX the gcc test will end up # making a dummy file named 'D' -- because '-MD' means "put the output # in D". rm -rf conftest.dir mkdir conftest.dir # Copy depcomp to subdir because otherwise we won't find it if we're # using a relative directory. cp "$am_depcomp" conftest.dir cd conftest.dir # We will build objects and dependencies in a subdirectory because # it helps to detect inapplicable dependency modes. For instance # both Tru64's cc and ICC support -MD to output dependencies as a # side effect of compilation, but ICC will put the dependencies in # the current directory while Tru64 will put them in the object # directory. mkdir sub am_cv_CC_dependencies_compiler_type=none if test "$am_compiler_list" = ""; then am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp` fi am__universal=false case " $depcc " in #( *\ -arch\ *\ -arch\ *) am__universal=true ;; esac for depmode in $am_compiler_list; do # Setup a source with many dependencies, because some compilers # like to wrap large dependency lists on column 80 (with \), and # we should not choose a depcomp mode which is confused by this. # # We need to recreate these files for each test, as the compiler may # overwrite some of them when testing with obscure command lines. # This happens at least with the AIX C compiler. : > sub/conftest.c for i in 1 2 3 4 5 6; do echo '#include "conftst'$i'.h"' >> sub/conftest.c # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with # Solaris 10 /bin/sh. echo '/* dummy */' > sub/conftst$i.h done echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf # We check with '-c' and '-o' for the sake of the "dashmstdout" # mode. It turns out that the SunPro C++ compiler does not properly # handle '-M -o', and we need to detect this. Also, some Intel # versions had trouble with output in subdirs. am__obj=sub/conftest.${OBJEXT-o} am__minus_obj="-o $am__obj" case $depmode in gcc) # This depmode causes a compiler race in universal mode. test "$am__universal" = false || continue ;; nosideeffect) # After this tag, mechanisms are not by side-effect, so they'll # only be used when explicitly requested. if test "x$enable_dependency_tracking" = xyes; then continue else break fi ;; msvc7 | msvc7msys | msvisualcpp | msvcmsys) # This compiler won't grok '-c -o', but also, the minuso test has # not run yet. These depmodes are late enough in the game, and # so weak that their functioning should not be impacted. am__obj=conftest.${OBJEXT-o} am__minus_obj= ;; none) break ;; esac if depmode=$depmode \ source=sub/conftest.c object=$am__obj \ depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \ $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \ >/dev/null 2>conftest.err && grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 && grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 && grep $am__obj sub/conftest.Po > /dev/null 2>&1 && ${MAKE-make} -s -f confmf > /dev/null 2>&1; then # icc doesn't choke on unknown options, it will just issue warnings # or remarks (even with -Werror). So we grep stderr for any message # that says an option was ignored or not supported. # When given -MP, icc 7.0 and 7.1 complain thusly: # icc: Command line warning: ignoring option '-M'; no argument required # The diagnosis changed in icc 8.0: # icc: Command line remark: option '-MP' not supported if (grep 'ignoring option' conftest.err || grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else am_cv_CC_dependencies_compiler_type=$depmode break fi fi done cd .. rm -rf conftest.dir else am_cv_CC_dependencies_compiler_type=none fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5 $as_echo "$am_cv_CC_dependencies_compiler_type" >&6; } CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type if test "x$enable_dependency_tracking" != xno \ && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then am__fastdepCC_TRUE= am__fastdepCC_FALSE='#' else am__fastdepCC_TRUE='#' am__fastdepCC_FALSE= fi if test -n "$ac_tool_prefix"; then for ac_prog in ar lib "link -lib" do # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. set dummy $ac_tool_prefix$ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_AR+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$AR"; then ac_cv_prog_AR="$AR" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_AR="$ac_tool_prefix$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi AR=$ac_cv_prog_AR if test -n "$AR"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5 $as_echo "$AR" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$AR" && break done fi if test -z "$AR"; then ac_ct_AR=$AR for ac_prog in ar lib "link -lib" do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_AR+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_AR"; then ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_AR="$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_AR=$ac_cv_prog_ac_ct_AR if test -n "$ac_ct_AR"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5 $as_echo "$ac_ct_AR" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$ac_ct_AR" && break done if test "x$ac_ct_AR" = x; then AR="false" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac AR=$ac_ct_AR fi fi : ${AR=ar} { $as_echo "$as_me:${as_lineno-$LINENO}: checking the archiver ($AR) interface" >&5 $as_echo_n "checking the archiver ($AR) interface... " >&6; } if ${am_cv_ar_interface+:} false; then : $as_echo_n "(cached) " >&6 else am_cv_ar_interface=ar cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int some_variable = 0; _ACEOF if ac_fn_c_try_compile "$LINENO"; then : am_ar_try='$AR cru libconftest.a conftest.$ac_objext >&5' { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$am_ar_try\""; } >&5 (eval $am_ar_try) 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } if test "$ac_status" -eq 0; then am_cv_ar_interface=ar else am_ar_try='$AR -NOLOGO -OUT:conftest.lib conftest.$ac_objext >&5' { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$am_ar_try\""; } >&5 (eval $am_ar_try) 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } if test "$ac_status" -eq 0; then am_cv_ar_interface=lib else am_cv_ar_interface=unknown fi fi rm -f conftest.lib libconftest.a fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_ar_interface" >&5 $as_echo "$am_cv_ar_interface" >&6; } case $am_cv_ar_interface in ar) ;; lib) # Microsoft lib, so override with the ar-lib wrapper script. # FIXME: It is wrong to rewrite AR. # But if we don't then we get into trouble of one sort or another. # A longer-term fix would be to have automake use am__AR in this case, # and then we could set am__AR="$am_aux_dir/ar-lib \$(AR)" or something # similar. AR="$am_aux_dir/ar-lib $AR" ;; unknown) as_fn_error $? "could not determine $AR interface" "$LINENO" 5 ;; esac case `pwd` in *\ * | *\ *) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&5 $as_echo "$as_me: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&2;} ;; esac macro_version='2.4.2' macro_revision='1.3337' ltmain="$ac_aux_dir/ltmain.sh" # Make sure we can run config.sub. $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 || as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5 { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5 $as_echo_n "checking build system type... " >&6; } if ${ac_cv_build+:} false; then : $as_echo_n "(cached) " >&6 else ac_build_alias=$build_alias test "x$ac_build_alias" = x && ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"` test "x$ac_build_alias" = x && as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5 ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` || as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5 fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5 $as_echo "$ac_cv_build" >&6; } case $ac_cv_build in *-*-*) ;; *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;; esac build=$ac_cv_build ac_save_IFS=$IFS; IFS='-' set x $ac_cv_build shift build_cpu=$1 build_vendor=$2 shift; shift # Remember, the first character of IFS is used to create $*, # except with old shells: build_os=$* IFS=$ac_save_IFS case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5 $as_echo_n "checking host system type... " >&6; } if ${ac_cv_host+:} false; then : $as_echo_n "(cached) " >&6 else if test "x$host_alias" = x; then ac_cv_host=$ac_cv_build else ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` || as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5 fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5 $as_echo "$ac_cv_host" >&6; } case $ac_cv_host in *-*-*) ;; *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;; esac host=$ac_cv_host ac_save_IFS=$IFS; IFS='-' set x $ac_cv_host shift host_cpu=$1 host_vendor=$2 shift; shift # Remember, the first character of IFS is used to create $*, # except with old shells: host_os=$* IFS=$ac_save_IFS case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac # Backslashify metacharacters that are still active within # double-quoted strings. sed_quote_subst='s/\(["`$\\]\)/\\\1/g' # Same as above, but do not quote variable references. double_quote_subst='s/\(["`\\]\)/\\\1/g' # Sed substitution to delay expansion of an escaped shell variable in a # double_quote_subst'ed string. delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g' # Sed substitution to delay expansion of an escaped single quote. delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g' # Sed substitution to avoid accidental globbing in evaled expressions no_glob_subst='s/\*/\\\*/g' ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to print strings" >&5 $as_echo_n "checking how to print strings... " >&6; } # Test print first, because it will be a builtin if present. if test "X`( print -r -- -n ) 2>/dev/null`" = X-n && \ test "X`print -r -- $ECHO 2>/dev/null`" = "X$ECHO"; then ECHO='print -r --' elif test "X`printf %s $ECHO 2>/dev/null`" = "X$ECHO"; then ECHO='printf %s\n' else # Use this function as a fallback that always works. func_fallback_echo () { eval 'cat <<_LTECHO_EOF $1 _LTECHO_EOF' } ECHO='func_fallback_echo' fi # func_echo_all arg... # Invoke $ECHO with all args, space-separated. func_echo_all () { $ECHO "" } case "$ECHO" in printf*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: printf" >&5 $as_echo "printf" >&6; } ;; print*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: print -r" >&5 $as_echo "print -r" >&6; } ;; *) { $as_echo "$as_me:${as_lineno-$LINENO}: result: cat" >&5 $as_echo "cat" >&6; } ;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5 $as_echo_n "checking for a sed that does not truncate output... " >&6; } if ${ac_cv_path_SED+:} false; then : $as_echo_n "(cached) " >&6 else ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/ for ac_i in 1 2 3 4 5 6 7; do ac_script="$ac_script$as_nl$ac_script" done echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed { ac_script=; unset ac_script;} if test -z "$SED"; then ac_path_SED_found=false # Loop through the user's path and test for each of PROGNAME-LIST as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_prog in sed gsed; do for ac_exec_ext in '' $ac_executable_extensions; do ac_path_SED="$as_dir/$ac_prog$ac_exec_ext" as_fn_executable_p "$ac_path_SED" || continue # Check for GNU ac_path_SED and select it if it is found. # Check for GNU $ac_path_SED case `"$ac_path_SED" --version 2>&1` in *GNU*) ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;; *) ac_count=0 $as_echo_n 0123456789 >"conftest.in" while : do cat "conftest.in" "conftest.in" >"conftest.tmp" mv "conftest.tmp" "conftest.in" cp "conftest.in" "conftest.nl" $as_echo '' >> "conftest.nl" "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val if test $ac_count -gt ${ac_path_SED_max-0}; then # Best one so far, save it but keep looking for a better one ac_cv_path_SED="$ac_path_SED" ac_path_SED_max=$ac_count fi # 10*(2^10) chars as input seems more than enough test $ac_count -gt 10 && break done rm -f conftest.in conftest.tmp conftest.nl conftest.out;; esac $ac_path_SED_found && break 3 done done done IFS=$as_save_IFS if test -z "$ac_cv_path_SED"; then as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5 fi else ac_cv_path_SED=$SED fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5 $as_echo "$ac_cv_path_SED" >&6; } SED="$ac_cv_path_SED" rm -f conftest.sed test -z "$SED" && SED=sed Xsed="$SED -e 1s/^X//" { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5 $as_echo_n "checking for grep that handles long lines and -e... " >&6; } if ${ac_cv_path_GREP+:} false; then : $as_echo_n "(cached) " >&6 else if test -z "$GREP"; then ac_path_GREP_found=false # Loop through the user's path and test for each of PROGNAME-LIST as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_prog in grep ggrep; do for ac_exec_ext in '' $ac_executable_extensions; do ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext" as_fn_executable_p "$ac_path_GREP" || continue # Check for GNU ac_path_GREP and select it if it is found. # Check for GNU $ac_path_GREP case `"$ac_path_GREP" --version 2>&1` in *GNU*) ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;; *) ac_count=0 $as_echo_n 0123456789 >"conftest.in" while : do cat "conftest.in" "conftest.in" >"conftest.tmp" mv "conftest.tmp" "conftest.in" cp "conftest.in" "conftest.nl" $as_echo 'GREP' >> "conftest.nl" "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val if test $ac_count -gt ${ac_path_GREP_max-0}; then # Best one so far, save it but keep looking for a better one ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_max=$ac_count fi # 10*(2^10) chars as input seems more than enough test $ac_count -gt 10 && break done rm -f conftest.in conftest.tmp conftest.nl conftest.out;; esac $ac_path_GREP_found && break 3 done done done IFS=$as_save_IFS if test -z "$ac_cv_path_GREP"; then as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 fi else ac_cv_path_GREP=$GREP fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5 $as_echo "$ac_cv_path_GREP" >&6; } GREP="$ac_cv_path_GREP" { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5 $as_echo_n "checking for egrep... " >&6; } if ${ac_cv_path_EGREP+:} false; then : $as_echo_n "(cached) " >&6 else if echo a | $GREP -E '(a|b)' >/dev/null 2>&1 then ac_cv_path_EGREP="$GREP -E" else if test -z "$EGREP"; then ac_path_EGREP_found=false # Loop through the user's path and test for each of PROGNAME-LIST as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_prog in egrep; do for ac_exec_ext in '' $ac_executable_extensions; do ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext" as_fn_executable_p "$ac_path_EGREP" || continue # Check for GNU ac_path_EGREP and select it if it is found. # Check for GNU $ac_path_EGREP case `"$ac_path_EGREP" --version 2>&1` in *GNU*) ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;; *) ac_count=0 $as_echo_n 0123456789 >"conftest.in" while : do cat "conftest.in" "conftest.in" >"conftest.tmp" mv "conftest.tmp" "conftest.in" cp "conftest.in" "conftest.nl" $as_echo 'EGREP' >> "conftest.nl" "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val if test $ac_count -gt ${ac_path_EGREP_max-0}; then # Best one so far, save it but keep looking for a better one ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_max=$ac_count fi # 10*(2^10) chars as input seems more than enough test $ac_count -gt 10 && break done rm -f conftest.in conftest.tmp conftest.nl conftest.out;; esac $ac_path_EGREP_found && break 3 done done done IFS=$as_save_IFS if test -z "$ac_cv_path_EGREP"; then as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 fi else ac_cv_path_EGREP=$EGREP fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5 $as_echo "$ac_cv_path_EGREP" >&6; } EGREP="$ac_cv_path_EGREP" { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5 $as_echo_n "checking for fgrep... " >&6; } if ${ac_cv_path_FGREP+:} false; then : $as_echo_n "(cached) " >&6 else if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1 then ac_cv_path_FGREP="$GREP -F" else if test -z "$FGREP"; then ac_path_FGREP_found=false # Loop through the user's path and test for each of PROGNAME-LIST as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_prog in fgrep; do for ac_exec_ext in '' $ac_executable_extensions; do ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext" as_fn_executable_p "$ac_path_FGREP" || continue # Check for GNU ac_path_FGREP and select it if it is found. # Check for GNU $ac_path_FGREP case `"$ac_path_FGREP" --version 2>&1` in *GNU*) ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;; *) ac_count=0 $as_echo_n 0123456789 >"conftest.in" while : do cat "conftest.in" "conftest.in" >"conftest.tmp" mv "conftest.tmp" "conftest.in" cp "conftest.in" "conftest.nl" $as_echo 'FGREP' >> "conftest.nl" "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val if test $ac_count -gt ${ac_path_FGREP_max-0}; then # Best one so far, save it but keep looking for a better one ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_max=$ac_count fi # 10*(2^10) chars as input seems more than enough test $ac_count -gt 10 && break done rm -f conftest.in conftest.tmp conftest.nl conftest.out;; esac $ac_path_FGREP_found && break 3 done done done IFS=$as_save_IFS if test -z "$ac_cv_path_FGREP"; then as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 fi else ac_cv_path_FGREP=$FGREP fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5 $as_echo "$ac_cv_path_FGREP" >&6; } FGREP="$ac_cv_path_FGREP" test -z "$GREP" && GREP=grep # Check whether --with-gnu-ld was given. if test "${with_gnu_ld+set}" = set; then : withval=$with_gnu_ld; test "$withval" = no || with_gnu_ld=yes else with_gnu_ld=no fi ac_prog=ld if test "$GCC" = yes; then # Check if gcc -print-prog-name=ld gives a path. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5 $as_echo_n "checking for ld used by $CC... " >&6; } case $host in *-*-mingw*) # gcc leaves a trailing carriage return which upsets mingw ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; *) ac_prog=`($CC -print-prog-name=ld) 2>&5` ;; esac case $ac_prog in # Accept absolute paths. [\\/]* | ?:[\\/]*) re_direlt='/[^/][^/]*/\.\./' # Canonicalize the pathname of ld ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'` while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"` done test -z "$LD" && LD="$ac_prog" ;; "") # If it fails, then pretend we aren't using GCC. ac_prog=ld ;; *) # If it is relative, then search for the first ld in PATH. with_gnu_ld=unknown ;; esac elif test "$with_gnu_ld" = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5 $as_echo_n "checking for GNU ld... " >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5 $as_echo_n "checking for non-GNU ld... " >&6; } fi if ${lt_cv_path_LD+:} false; then : $as_echo_n "(cached) " >&6 else if test -z "$LD"; then lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR for ac_dir in $PATH; do IFS="$lt_save_ifs" test -z "$ac_dir" && ac_dir=. if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then lt_cv_path_LD="$ac_dir/$ac_prog" # Check to see if the program is GNU ld. I'd rather use --version, # but apparently some variants of GNU ld only accept -v. # Break only if it was the GNU/non-GNU ld that we prefer. case `"$lt_cv_path_LD" -v 2>&1 &5 $as_echo "$LD" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -z "$LD" && as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5 $as_echo_n "checking if the linker ($LD) is GNU ld... " >&6; } if ${lt_cv_prog_gnu_ld+:} false; then : $as_echo_n "(cached) " >&6 else # I'd rather use --version here, but apparently some GNU lds only accept -v. case `$LD -v 2>&1 &5 $as_echo "$lt_cv_prog_gnu_ld" >&6; } with_gnu_ld=$lt_cv_prog_gnu_ld { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BSD- or MS-compatible name lister (nm)" >&5 $as_echo_n "checking for BSD- or MS-compatible name lister (nm)... " >&6; } if ${lt_cv_path_NM+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$NM"; then # Let the user override the test. lt_cv_path_NM="$NM" else lt_nm_to_check="${ac_tool_prefix}nm" if test -n "$ac_tool_prefix" && test "$build" = "$host"; then lt_nm_to_check="$lt_nm_to_check nm" fi for lt_tmp_nm in $lt_nm_to_check; do lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do IFS="$lt_save_ifs" test -z "$ac_dir" && ac_dir=. tmp_nm="$ac_dir/$lt_tmp_nm" if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then # Check to see if the nm accepts a BSD-compat flag. # Adding the `sed 1q' prevents false positives on HP-UX, which says: # nm: unknown option "B" ignored # Tru64's nm complains that /dev/null is an invalid object file case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in */dev/null* | *'Invalid file or object type'*) lt_cv_path_NM="$tmp_nm -B" break ;; *) case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in */dev/null*) lt_cv_path_NM="$tmp_nm -p" break ;; *) lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but continue # so that we can try to find one that supports BSD flags ;; esac ;; esac fi done IFS="$lt_save_ifs" done : ${lt_cv_path_NM=no} fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_NM" >&5 $as_echo "$lt_cv_path_NM" >&6; } if test "$lt_cv_path_NM" != "no"; then NM="$lt_cv_path_NM" else # Didn't find any BSD compatible name lister, look for dumpbin. if test -n "$DUMPBIN"; then : # Let the user override the test. else if test -n "$ac_tool_prefix"; then for ac_prog in dumpbin "link -dump" do # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. set dummy $ac_tool_prefix$ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_DUMPBIN+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$DUMPBIN"; then ac_cv_prog_DUMPBIN="$DUMPBIN" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_DUMPBIN="$ac_tool_prefix$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi DUMPBIN=$ac_cv_prog_DUMPBIN if test -n "$DUMPBIN"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5 $as_echo "$DUMPBIN" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$DUMPBIN" && break done fi if test -z "$DUMPBIN"; then ac_ct_DUMPBIN=$DUMPBIN for ac_prog in dumpbin "link -dump" do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_DUMPBIN+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_DUMPBIN"; then ac_cv_prog_ac_ct_DUMPBIN="$ac_ct_DUMPBIN" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_DUMPBIN="$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_DUMPBIN=$ac_cv_prog_ac_ct_DUMPBIN if test -n "$ac_ct_DUMPBIN"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DUMPBIN" >&5 $as_echo "$ac_ct_DUMPBIN" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$ac_ct_DUMPBIN" && break done if test "x$ac_ct_DUMPBIN" = x; then DUMPBIN=":" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac DUMPBIN=$ac_ct_DUMPBIN fi fi case `$DUMPBIN -symbols /dev/null 2>&1 | sed '1q'` in *COFF*) DUMPBIN="$DUMPBIN -symbols" ;; *) DUMPBIN=: ;; esac fi if test "$DUMPBIN" != ":"; then NM="$DUMPBIN" fi fi test -z "$NM" && NM=nm { $as_echo "$as_me:${as_lineno-$LINENO}: checking the name lister ($NM) interface" >&5 $as_echo_n "checking the name lister ($NM) interface... " >&6; } if ${lt_cv_nm_interface+:} false; then : $as_echo_n "(cached) " >&6 else lt_cv_nm_interface="BSD nm" echo "int some_variable = 0;" > conftest.$ac_ext (eval echo "\"\$as_me:$LINENO: $ac_compile\"" >&5) (eval "$ac_compile" 2>conftest.err) cat conftest.err >&5 (eval echo "\"\$as_me:$LINENO: $NM \\\"conftest.$ac_objext\\\"\"" >&5) (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out) cat conftest.err >&5 (eval echo "\"\$as_me:$LINENO: output\"" >&5) cat conftest.out >&5 if $GREP 'External.*some_variable' conftest.out > /dev/null; then lt_cv_nm_interface="MS dumpbin" fi rm -f conftest* fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_nm_interface" >&5 $as_echo "$lt_cv_nm_interface" >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ln -s works" >&5 $as_echo_n "checking whether ln -s works... " >&6; } LN_S=$as_ln_s if test "$LN_S" = "ln -s"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, using $LN_S" >&5 $as_echo "no, using $LN_S" >&6; } fi # find the maximum length of command line arguments { $as_echo "$as_me:${as_lineno-$LINENO}: checking the maximum length of command line arguments" >&5 $as_echo_n "checking the maximum length of command line arguments... " >&6; } if ${lt_cv_sys_max_cmd_len+:} false; then : $as_echo_n "(cached) " >&6 else i=0 teststring="ABCD" case $build_os in msdosdjgpp*) # On DJGPP, this test can blow up pretty badly due to problems in libc # (any single argument exceeding 2000 bytes causes a buffer overrun # during glob expansion). Even if it were fixed, the result of this # check would be larger than it should be. lt_cv_sys_max_cmd_len=12288; # 12K is about right ;; gnu*) # Under GNU Hurd, this test is not required because there is # no limit to the length of command line arguments. # Libtool will interpret -1 as no limit whatsoever lt_cv_sys_max_cmd_len=-1; ;; cygwin* | mingw* | cegcc*) # On Win9x/ME, this test blows up -- it succeeds, but takes # about 5 minutes as the teststring grows exponentially. # Worse, since 9x/ME are not pre-emptively multitasking, # you end up with a "frozen" computer, even though with patience # the test eventually succeeds (with a max line length of 256k). # Instead, let's just punt: use the minimum linelength reported by # all of the supported platforms: 8192 (on NT/2K/XP). lt_cv_sys_max_cmd_len=8192; ;; mint*) # On MiNT this can take a long time and run out of memory. lt_cv_sys_max_cmd_len=8192; ;; amigaos*) # On AmigaOS with pdksh, this test takes hours, literally. # So we just punt and use a minimum line length of 8192. lt_cv_sys_max_cmd_len=8192; ;; netbsd* | freebsd* | openbsd* | darwin* | dragonfly*) # This has been around since 386BSD, at least. Likely further. if test -x /sbin/sysctl; then lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax` elif test -x /usr/sbin/sysctl; then lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax` else lt_cv_sys_max_cmd_len=65536 # usable default for all BSDs fi # And add a safety zone lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4` lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3` ;; interix*) # We know the value 262144 and hardcode it with a safety zone (like BSD) lt_cv_sys_max_cmd_len=196608 ;; osf*) # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not # nice to cause kernel panics so lets avoid the loop below. # First set a reasonable default. lt_cv_sys_max_cmd_len=16384 # if test -x /sbin/sysconfig; then case `/sbin/sysconfig -q proc exec_disable_arg_limit` in *1*) lt_cv_sys_max_cmd_len=-1 ;; esac fi ;; sco3.2v5*) lt_cv_sys_max_cmd_len=102400 ;; sysv5* | sco5v6* | sysv4.2uw2*) kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null` if test -n "$kargmax"; then lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[ ]//'` else lt_cv_sys_max_cmd_len=32768 fi ;; *) lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null` if test -n "$lt_cv_sys_max_cmd_len"; then lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4` lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3` else # Make teststring a little bigger before we do anything with it. # a 1K string should be a reasonable start. for i in 1 2 3 4 5 6 7 8 ; do teststring=$teststring$teststring done SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}} # If test is not a shell built-in, we'll probably end up computing a # maximum length that is only half of the actual maximum length, but # we can't tell. while { test "X"`func_fallback_echo "$teststring$teststring" 2>/dev/null` \ = "X$teststring$teststring"; } >/dev/null 2>&1 && test $i != 17 # 1/2 MB should be enough do i=`expr $i + 1` teststring=$teststring$teststring done # Only check the string length outside the loop. lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1` teststring= # Add a significant safety factor because C++ compilers can tack on # massive amounts of additional arguments before passing them to the # linker. It appears as though 1/2 is a usable value. lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2` fi ;; esac fi if test -n $lt_cv_sys_max_cmd_len ; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sys_max_cmd_len" >&5 $as_echo "$lt_cv_sys_max_cmd_len" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: none" >&5 $as_echo "none" >&6; } fi max_cmd_len=$lt_cv_sys_max_cmd_len : ${CP="cp -f"} : ${MV="mv -f"} : ${RM="rm -f"} { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the shell understands some XSI constructs" >&5 $as_echo_n "checking whether the shell understands some XSI constructs... " >&6; } # Try some XSI features xsi_shell=no ( _lt_dummy="a/b/c" test "${_lt_dummy##*/},${_lt_dummy%/*},${_lt_dummy#??}"${_lt_dummy%"$_lt_dummy"}, \ = c,a/b,b/c, \ && eval 'test $(( 1 + 1 )) -eq 2 \ && test "${#_lt_dummy}" -eq 5' ) >/dev/null 2>&1 \ && xsi_shell=yes { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xsi_shell" >&5 $as_echo "$xsi_shell" >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the shell understands \"+=\"" >&5 $as_echo_n "checking whether the shell understands \"+=\"... " >&6; } lt_shell_append=no ( foo=bar; set foo baz; eval "$1+=\$2" && test "$foo" = barbaz ) \ >/dev/null 2>&1 \ && lt_shell_append=yes { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_shell_append" >&5 $as_echo "$lt_shell_append" >&6; } if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then lt_unset=unset else lt_unset=false fi # test EBCDIC or ASCII case `echo X|tr X '\101'` in A) # ASCII based system # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr lt_SP2NL='tr \040 \012' lt_NL2SP='tr \015\012 \040\040' ;; *) # EBCDIC based system lt_SP2NL='tr \100 \n' lt_NL2SP='tr \r\n \100\100' ;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to $host format" >&5 $as_echo_n "checking how to convert $build file names to $host format... " >&6; } if ${lt_cv_to_host_file_cmd+:} false; then : $as_echo_n "(cached) " >&6 else case $host in *-*-mingw* ) case $build in *-*-mingw* ) # actually msys lt_cv_to_host_file_cmd=func_convert_file_msys_to_w32 ;; *-*-cygwin* ) lt_cv_to_host_file_cmd=func_convert_file_cygwin_to_w32 ;; * ) # otherwise, assume *nix lt_cv_to_host_file_cmd=func_convert_file_nix_to_w32 ;; esac ;; *-*-cygwin* ) case $build in *-*-mingw* ) # actually msys lt_cv_to_host_file_cmd=func_convert_file_msys_to_cygwin ;; *-*-cygwin* ) lt_cv_to_host_file_cmd=func_convert_file_noop ;; * ) # otherwise, assume *nix lt_cv_to_host_file_cmd=func_convert_file_nix_to_cygwin ;; esac ;; * ) # unhandled hosts (and "normal" native builds) lt_cv_to_host_file_cmd=func_convert_file_noop ;; esac fi to_host_file_cmd=$lt_cv_to_host_file_cmd { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_host_file_cmd" >&5 $as_echo "$lt_cv_to_host_file_cmd" >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to toolchain format" >&5 $as_echo_n "checking how to convert $build file names to toolchain format... " >&6; } if ${lt_cv_to_tool_file_cmd+:} false; then : $as_echo_n "(cached) " >&6 else #assume ordinary cross tools, or native build. lt_cv_to_tool_file_cmd=func_convert_file_noop case $host in *-*-mingw* ) case $build in *-*-mingw* ) # actually msys lt_cv_to_tool_file_cmd=func_convert_file_msys_to_w32 ;; esac ;; esac fi to_tool_file_cmd=$lt_cv_to_tool_file_cmd { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_tool_file_cmd" >&5 $as_echo "$lt_cv_to_tool_file_cmd" >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $LD option to reload object files" >&5 $as_echo_n "checking for $LD option to reload object files... " >&6; } if ${lt_cv_ld_reload_flag+:} false; then : $as_echo_n "(cached) " >&6 else lt_cv_ld_reload_flag='-r' fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_reload_flag" >&5 $as_echo "$lt_cv_ld_reload_flag" >&6; } reload_flag=$lt_cv_ld_reload_flag case $reload_flag in "" | " "*) ;; *) reload_flag=" $reload_flag" ;; esac reload_cmds='$LD$reload_flag -o $output$reload_objs' case $host_os in cygwin* | mingw* | pw32* | cegcc*) if test "$GCC" != yes; then reload_cmds=false fi ;; darwin*) if test "$GCC" = yes; then reload_cmds='$LTCC $LTCFLAGS -nostdlib ${wl}-r -o $output$reload_objs' else reload_cmds='$LD$reload_flag -o $output$reload_objs' fi ;; esac if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args. set dummy ${ac_tool_prefix}objdump; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_OBJDUMP+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$OBJDUMP"; then ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi OBJDUMP=$ac_cv_prog_OBJDUMP if test -n "$OBJDUMP"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5 $as_echo "$OBJDUMP" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$ac_cv_prog_OBJDUMP"; then ac_ct_OBJDUMP=$OBJDUMP # Extract the first word of "objdump", so it can be a program name with args. set dummy objdump; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_OBJDUMP+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_OBJDUMP"; then ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OBJDUMP="objdump" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP if test -n "$ac_ct_OBJDUMP"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5 $as_echo "$ac_ct_OBJDUMP" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test "x$ac_ct_OBJDUMP" = x; then OBJDUMP="false" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac OBJDUMP=$ac_ct_OBJDUMP fi else OBJDUMP="$ac_cv_prog_OBJDUMP" fi test -z "$OBJDUMP" && OBJDUMP=objdump { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to recognize dependent libraries" >&5 $as_echo_n "checking how to recognize dependent libraries... " >&6; } if ${lt_cv_deplibs_check_method+:} false; then : $as_echo_n "(cached) " >&6 else lt_cv_file_magic_cmd='$MAGIC_CMD' lt_cv_file_magic_test_file= lt_cv_deplibs_check_method='unknown' # Need to set the preceding variable on all platforms that support # interlibrary dependencies. # 'none' -- dependencies not supported. # `unknown' -- same as none, but documents that we really don't know. # 'pass_all' -- all dependencies passed with no checks. # 'test_compile' -- check by making test program. # 'file_magic [[regex]]' -- check by looking for files in library path # which responds to the $file_magic_cmd with a given extended regex. # If you have `file' or equivalent on your system and you're not sure # whether `pass_all' will *always* work, you probably want this one. case $host_os in aix[4-9]*) lt_cv_deplibs_check_method=pass_all ;; beos*) lt_cv_deplibs_check_method=pass_all ;; bsdi[45]*) lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)' lt_cv_file_magic_cmd='/usr/bin/file -L' lt_cv_file_magic_test_file=/shlib/libc.so ;; cygwin*) # func_win32_libid is a shell function defined in ltmain.sh lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL' lt_cv_file_magic_cmd='func_win32_libid' ;; mingw* | pw32*) # Base MSYS/MinGW do not provide the 'file' command needed by # func_win32_libid shell function, so use a weaker test based on 'objdump', # unless we find 'file', for example because we are cross-compiling. # func_win32_libid assumes BSD nm, so disallow it if using MS dumpbin. if ( test "$lt_cv_nm_interface" = "BSD nm" && file / ) >/dev/null 2>&1; then lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL' lt_cv_file_magic_cmd='func_win32_libid' else # Keep this pattern in sync with the one in func_win32_libid. lt_cv_deplibs_check_method='file_magic file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' lt_cv_file_magic_cmd='$OBJDUMP -f' fi ;; cegcc*) # use the weaker test based on 'objdump'. See mingw*. lt_cv_deplibs_check_method='file_magic file format pe-arm-.*little(.*architecture: arm)?' lt_cv_file_magic_cmd='$OBJDUMP -f' ;; darwin* | rhapsody*) lt_cv_deplibs_check_method=pass_all ;; freebsd* | dragonfly*) if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then case $host_cpu in i*86 ) # Not sure whether the presence of OpenBSD here was a mistake. # Let's accept both of them until this is cleared up. lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[3-9]86 (compact )?demand paged shared library' lt_cv_file_magic_cmd=/usr/bin/file lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*` ;; esac else lt_cv_deplibs_check_method=pass_all fi ;; gnu*) lt_cv_deplibs_check_method=pass_all ;; haiku*) lt_cv_deplibs_check_method=pass_all ;; hpux10.20* | hpux11*) lt_cv_file_magic_cmd=/usr/bin/file case $host_cpu in ia64*) lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - IA64' lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so ;; hppa*64*) lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF[ -][0-9][0-9])(-bit)?( [LM]SB)? shared object( file)?[, -]* PA-RISC [0-9]\.[0-9]' lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl ;; *) lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9]\.[0-9]) shared library' lt_cv_file_magic_test_file=/usr/lib/libc.sl ;; esac ;; interix[3-9]*) # PIC code is broken on Interix 3.x, that's why |\.a not |_pic\.a here lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|\.a)$' ;; irix5* | irix6* | nonstopux*) case $LD in *-32|*"-32 ") libmagic=32-bit;; *-n32|*"-n32 ") libmagic=N32;; *-64|*"-64 ") libmagic=64-bit;; *) libmagic=never-match;; esac lt_cv_deplibs_check_method=pass_all ;; # This must be Linux ELF. linux* | k*bsd*-gnu | kopensolaris*-gnu) lt_cv_deplibs_check_method=pass_all ;; netbsd*) if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$' else lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|_pic\.a)$' fi ;; newos6*) lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (executable|dynamic lib)' lt_cv_file_magic_cmd=/usr/bin/file lt_cv_file_magic_test_file=/usr/lib/libnls.so ;; *nto* | *qnx*) lt_cv_deplibs_check_method=pass_all ;; openbsd*) if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|\.so|_pic\.a)$' else lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$' fi ;; osf3* | osf4* | osf5*) lt_cv_deplibs_check_method=pass_all ;; rdos*) lt_cv_deplibs_check_method=pass_all ;; solaris*) lt_cv_deplibs_check_method=pass_all ;; sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*) lt_cv_deplibs_check_method=pass_all ;; sysv4 | sysv4.3*) case $host_vendor in motorola) lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9]* Version [0-9]' lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*` ;; ncr) lt_cv_deplibs_check_method=pass_all ;; sequent) lt_cv_file_magic_cmd='/bin/file' lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB (shared object|dynamic lib )' ;; sni) lt_cv_file_magic_cmd='/bin/file' lt_cv_deplibs_check_method="file_magic ELF [0-9][0-9]*-bit [LM]SB dynamic lib" lt_cv_file_magic_test_file=/lib/libc.so ;; siemens) lt_cv_deplibs_check_method=pass_all ;; pc) lt_cv_deplibs_check_method=pass_all ;; esac ;; tpf*) lt_cv_deplibs_check_method=pass_all ;; esac fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_deplibs_check_method" >&5 $as_echo "$lt_cv_deplibs_check_method" >&6; } file_magic_glob= want_nocaseglob=no if test "$build" = "$host"; then case $host_os in mingw* | pw32*) if ( shopt | grep nocaseglob ) >/dev/null 2>&1; then want_nocaseglob=yes else file_magic_glob=`echo aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ | $SED -e "s/\(..\)/s\/[\1]\/[\1]\/g;/g"` fi ;; esac fi file_magic_cmd=$lt_cv_file_magic_cmd deplibs_check_method=$lt_cv_deplibs_check_method test -z "$deplibs_check_method" && deplibs_check_method=unknown if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}dlltool", so it can be a program name with args. set dummy ${ac_tool_prefix}dlltool; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_DLLTOOL+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$DLLTOOL"; then ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_DLLTOOL="${ac_tool_prefix}dlltool" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi DLLTOOL=$ac_cv_prog_DLLTOOL if test -n "$DLLTOOL"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5 $as_echo "$DLLTOOL" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$ac_cv_prog_DLLTOOL"; then ac_ct_DLLTOOL=$DLLTOOL # Extract the first word of "dlltool", so it can be a program name with args. set dummy dlltool; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_DLLTOOL+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_DLLTOOL"; then ac_cv_prog_ac_ct_DLLTOOL="$ac_ct_DLLTOOL" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_DLLTOOL="dlltool" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_DLLTOOL=$ac_cv_prog_ac_ct_DLLTOOL if test -n "$ac_ct_DLLTOOL"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5 $as_echo "$ac_ct_DLLTOOL" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test "x$ac_ct_DLLTOOL" = x; then DLLTOOL="false" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac DLLTOOL=$ac_ct_DLLTOOL fi else DLLTOOL="$ac_cv_prog_DLLTOOL" fi test -z "$DLLTOOL" && DLLTOOL=dlltool { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to associate runtime and link libraries" >&5 $as_echo_n "checking how to associate runtime and link libraries... " >&6; } if ${lt_cv_sharedlib_from_linklib_cmd+:} false; then : $as_echo_n "(cached) " >&6 else lt_cv_sharedlib_from_linklib_cmd='unknown' case $host_os in cygwin* | mingw* | pw32* | cegcc*) # two different shell functions defined in ltmain.sh # decide which to use based on capabilities of $DLLTOOL case `$DLLTOOL --help 2>&1` in *--identify-strict*) lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib ;; *) lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib_fallback ;; esac ;; *) # fallback: assume linklib IS sharedlib lt_cv_sharedlib_from_linklib_cmd="$ECHO" ;; esac fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sharedlib_from_linklib_cmd" >&5 $as_echo "$lt_cv_sharedlib_from_linklib_cmd" >&6; } sharedlib_from_linklib_cmd=$lt_cv_sharedlib_from_linklib_cmd test -z "$sharedlib_from_linklib_cmd" && sharedlib_from_linklib_cmd=$ECHO if test -n "$ac_tool_prefix"; then for ac_prog in ar do # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. set dummy $ac_tool_prefix$ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_AR+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$AR"; then ac_cv_prog_AR="$AR" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_AR="$ac_tool_prefix$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi AR=$ac_cv_prog_AR if test -n "$AR"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5 $as_echo "$AR" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$AR" && break done fi if test -z "$AR"; then ac_ct_AR=$AR for ac_prog in ar do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_AR+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_AR"; then ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_AR="$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_AR=$ac_cv_prog_ac_ct_AR if test -n "$ac_ct_AR"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5 $as_echo "$ac_ct_AR" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$ac_ct_AR" && break done if test "x$ac_ct_AR" = x; then AR="false" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac AR=$ac_ct_AR fi fi : ${AR=ar} : ${AR_FLAGS=cru} { $as_echo "$as_me:${as_lineno-$LINENO}: checking for archiver @FILE support" >&5 $as_echo_n "checking for archiver @FILE support... " >&6; } if ${lt_cv_ar_at_file+:} false; then : $as_echo_n "(cached) " >&6 else lt_cv_ar_at_file=no cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : echo conftest.$ac_objext > conftest.lst lt_ar_try='$AR $AR_FLAGS libconftest.a @conftest.lst >&5' { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$lt_ar_try\""; } >&5 (eval $lt_ar_try) 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } if test "$ac_status" -eq 0; then # Ensure the archiver fails upon bogus file names. rm -f conftest.$ac_objext libconftest.a { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$lt_ar_try\""; } >&5 (eval $lt_ar_try) 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } if test "$ac_status" -ne 0; then lt_cv_ar_at_file=@ fi fi rm -f conftest.* libconftest.a fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ar_at_file" >&5 $as_echo "$lt_cv_ar_at_file" >&6; } if test "x$lt_cv_ar_at_file" = xno; then archiver_list_spec= else archiver_list_spec=$lt_cv_ar_at_file fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args. set dummy ${ac_tool_prefix}strip; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_STRIP+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$STRIP"; then ac_cv_prog_STRIP="$STRIP" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_STRIP="${ac_tool_prefix}strip" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi STRIP=$ac_cv_prog_STRIP if test -n "$STRIP"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5 $as_echo "$STRIP" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$ac_cv_prog_STRIP"; then ac_ct_STRIP=$STRIP # Extract the first word of "strip", so it can be a program name with args. set dummy strip; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_STRIP+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_STRIP"; then ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_STRIP="strip" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP if test -n "$ac_ct_STRIP"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5 $as_echo "$ac_ct_STRIP" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test "x$ac_ct_STRIP" = x; then STRIP=":" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac STRIP=$ac_ct_STRIP fi else STRIP="$ac_cv_prog_STRIP" fi test -z "$STRIP" && STRIP=: if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args. set dummy ${ac_tool_prefix}ranlib; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_RANLIB+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$RANLIB"; then ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi RANLIB=$ac_cv_prog_RANLIB if test -n "$RANLIB"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5 $as_echo "$RANLIB" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$ac_cv_prog_RANLIB"; then ac_ct_RANLIB=$RANLIB # Extract the first word of "ranlib", so it can be a program name with args. set dummy ranlib; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_RANLIB+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_RANLIB"; then ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_RANLIB="ranlib" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB if test -n "$ac_ct_RANLIB"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5 $as_echo "$ac_ct_RANLIB" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test "x$ac_ct_RANLIB" = x; then RANLIB=":" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac RANLIB=$ac_ct_RANLIB fi else RANLIB="$ac_cv_prog_RANLIB" fi test -z "$RANLIB" && RANLIB=: # Determine commands to create old-style static archives. old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs' old_postinstall_cmds='chmod 644 $oldlib' old_postuninstall_cmds= if test -n "$RANLIB"; then case $host_os in openbsd*) old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$oldlib" ;; *) old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$oldlib" ;; esac old_archive_cmds="$old_archive_cmds~\$RANLIB \$oldlib" fi case $host_os in darwin*) lock_old_archive_extraction=yes ;; *) lock_old_archive_extraction=no ;; esac # If no C compiler was specified, use CC. LTCC=${LTCC-"$CC"} # If no C compiler flags were specified, use CFLAGS. LTCFLAGS=${LTCFLAGS-"$CFLAGS"} # Allow CC to be a program name with arguments. compiler=$CC # Check for command to grab the raw symbol name followed by C symbol from nm. { $as_echo "$as_me:${as_lineno-$LINENO}: checking command to parse $NM output from $compiler object" >&5 $as_echo_n "checking command to parse $NM output from $compiler object... " >&6; } if ${lt_cv_sys_global_symbol_pipe+:} false; then : $as_echo_n "(cached) " >&6 else # These are sane defaults that work on at least a few old systems. # [They come from Ultrix. What could be older than Ultrix?!! ;)] # Character class describing NM global symbol codes. symcode='[BCDEGRST]' # Regexp to match symbols that can be accessed directly from C. sympat='\([_A-Za-z][_A-Za-z0-9]*\)' # Define system-specific variables. case $host_os in aix*) symcode='[BCDT]' ;; cygwin* | mingw* | pw32* | cegcc*) symcode='[ABCDGISTW]' ;; hpux*) if test "$host_cpu" = ia64; then symcode='[ABCDEGRST]' fi ;; irix* | nonstopux*) symcode='[BCDEGRST]' ;; osf*) symcode='[BCDEGQRST]' ;; solaris*) symcode='[BDRT]' ;; sco3.2v5*) symcode='[DT]' ;; sysv4.2uw2*) symcode='[DT]' ;; sysv5* | sco5v6* | unixware* | OpenUNIX*) symcode='[ABDT]' ;; sysv4) symcode='[DFNSTU]' ;; esac # If we're using GNU nm, then use its standard symbol codes. case `$NM -V 2>&1` in *GNU* | *'with BFD'*) symcode='[ABCDGIRSTW]' ;; esac # Transform an extracted symbol line into a proper C declaration. # Some systems (esp. on ia64) link data and code symbols differently, # so use this general approach. lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'" # Transform an extracted symbol line into symbol name and symbol address lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([^ ]*\)[ ]*$/ {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/ {\"\2\", (void *) \&\2},/p'" lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: \([^ ]*\)[ ]*$/ {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([^ ]*\) \(lib[^ ]*\)$/ {\"\2\", (void *) \&\2},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/ {\"lib\2\", (void *) \&\2},/p'" # Handle CRLF in mingw tool chain opt_cr= case $build_os in mingw*) opt_cr=`$ECHO 'x\{0,1\}' | tr x '\015'` # option cr in regexp ;; esac # Try without a prefix underscore, then with it. for ac_symprfx in "" "_"; do # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol. symxfrm="\\1 $ac_symprfx\\2 \\2" # Write the raw and C identifiers. if test "$lt_cv_nm_interface" = "MS dumpbin"; then # Fake it for dumpbin and say T for any non-static function # and D for any global variable. # Also find C++ and __fastcall symbols from MSVC++, # which start with @ or ?. lt_cv_sys_global_symbol_pipe="$AWK '"\ " {last_section=section; section=\$ 3};"\ " /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\ " \$ 0!~/External *\|/{next};"\ " / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\ " {if(hide[section]) next};"\ " {f=0}; \$ 0~/\(\).*\|/{f=1}; {printf f ? \"T \" : \"D \"};"\ " {split(\$ 0, a, /\||\r/); split(a[2], s)};"\ " s[1]~/^[@?]/{print s[1], s[1]; next};"\ " s[1]~prfx {split(s[1],t,\"@\"); print t[1], substr(t[1],length(prfx))}"\ " ' prfx=^$ac_symprfx" else lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[ ]\($symcode$symcode*\)[ ][ ]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'" fi lt_cv_sys_global_symbol_pipe="$lt_cv_sys_global_symbol_pipe | sed '/ __gnu_lto/d'" # Check to see that the pipe works correctly. pipe_works=no rm -f conftest* cat > conftest.$ac_ext <<_LT_EOF #ifdef __cplusplus extern "C" { #endif char nm_test_var; void nm_test_func(void); void nm_test_func(void){} #ifdef __cplusplus } #endif int main(){nm_test_var='a';nm_test_func();return(0);} _LT_EOF if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 (eval $ac_compile) 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then # Now try to grab the symbols. nlist=conftest.nm if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist\""; } >&5 (eval $NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist) 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && test -s "$nlist"; then # Try sorting and uniquifying the output. if sort "$nlist" | uniq > "$nlist"T; then mv -f "$nlist"T "$nlist" else rm -f "$nlist"T fi # Make sure that we snagged all the symbols we need. if $GREP ' nm_test_var$' "$nlist" >/dev/null; then if $GREP ' nm_test_func$' "$nlist" >/dev/null; then cat <<_LT_EOF > conftest.$ac_ext /* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */ #if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE) /* DATA imports from DLLs on WIN32 con't be const, because runtime relocations are performed -- see ld's documentation on pseudo-relocs. */ # define LT_DLSYM_CONST #elif defined(__osf__) /* This system does not cope well with relocations in const data. */ # define LT_DLSYM_CONST #else # define LT_DLSYM_CONST const #endif #ifdef __cplusplus extern "C" { #endif _LT_EOF # Now generate the symbol file. eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | $GREP -v main >> conftest.$ac_ext' cat <<_LT_EOF >> conftest.$ac_ext /* The mapping between symbol names and symbols. */ LT_DLSYM_CONST struct { const char *name; void *address; } lt__PROGRAM__LTX_preloaded_symbols[] = { { "@PROGRAM@", (void *) 0 }, _LT_EOF $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/ {\"\2\", (void *) \&\2},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext cat <<\_LT_EOF >> conftest.$ac_ext {0, (void *) 0} }; /* This works around a problem in FreeBSD linker */ #ifdef FREEBSD_WORKAROUND static const void *lt_preloaded_setup() { return lt__PROGRAM__LTX_preloaded_symbols; } #endif #ifdef __cplusplus } #endif _LT_EOF # Now try linking the two files. mv conftest.$ac_objext conftstm.$ac_objext lt_globsym_save_LIBS=$LIBS lt_globsym_save_CFLAGS=$CFLAGS LIBS="conftstm.$ac_objext" CFLAGS="$CFLAGS$lt_prog_compiler_no_builtin_flag" if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 (eval $ac_link) 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && test -s conftest${ac_exeext}; then pipe_works=yes fi LIBS=$lt_globsym_save_LIBS CFLAGS=$lt_globsym_save_CFLAGS else echo "cannot find nm_test_func in $nlist" >&5 fi else echo "cannot find nm_test_var in $nlist" >&5 fi else echo "cannot run $lt_cv_sys_global_symbol_pipe" >&5 fi else echo "$progname: failed program was:" >&5 cat conftest.$ac_ext >&5 fi rm -rf conftest* conftst* # Do not use the global_symbol_pipe unless it works. if test "$pipe_works" = yes; then break else lt_cv_sys_global_symbol_pipe= fi done fi if test -z "$lt_cv_sys_global_symbol_pipe"; then lt_cv_sys_global_symbol_to_cdecl= fi if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5 $as_echo "failed" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5 $as_echo "ok" >&6; } fi # Response file support. if test "$lt_cv_nm_interface" = "MS dumpbin"; then nm_file_list_spec='@' elif $NM --help 2>/dev/null | grep '[@]FILE' >/dev/null; then nm_file_list_spec='@' fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5 $as_echo_n "checking for sysroot... " >&6; } # Check whether --with-sysroot was given. if test "${with_sysroot+set}" = set; then : withval=$with_sysroot; else with_sysroot=no fi lt_sysroot= case ${with_sysroot} in #( yes) if test "$GCC" = yes; then lt_sysroot=`$CC --print-sysroot 2>/dev/null` fi ;; #( /*) lt_sysroot=`echo "$with_sysroot" | sed -e "$sed_quote_subst"` ;; #( no|'') ;; #( *) { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${with_sysroot}" >&5 $as_echo "${with_sysroot}" >&6; } as_fn_error $? "The sysroot must be an absolute path." "$LINENO" 5 ;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${lt_sysroot:-no}" >&5 $as_echo "${lt_sysroot:-no}" >&6; } # Check whether --enable-libtool-lock was given. if test "${enable_libtool_lock+set}" = set; then : enableval=$enable_libtool_lock; fi test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes # Some flags need to be propagated to the compiler or linker for good # libtool support. case $host in ia64-*-hpux*) # Find out which ABI we are using. echo 'int i;' > conftest.$ac_ext if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 (eval $ac_compile) 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then case `/usr/bin/file conftest.$ac_objext` in *ELF-32*) HPUX_IA64_MODE="32" ;; *ELF-64*) HPUX_IA64_MODE="64" ;; esac fi rm -rf conftest* ;; *-*-irix6*) # Find out which ABI we are using. echo '#line '$LINENO' "configure"' > conftest.$ac_ext if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 (eval $ac_compile) 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then if test "$lt_cv_prog_gnu_ld" = yes; then case `/usr/bin/file conftest.$ac_objext` in *32-bit*) LD="${LD-ld} -melf32bsmip" ;; *N32*) LD="${LD-ld} -melf32bmipn32" ;; *64-bit*) LD="${LD-ld} -melf64bmip" ;; esac else case `/usr/bin/file conftest.$ac_objext` in *32-bit*) LD="${LD-ld} -32" ;; *N32*) LD="${LD-ld} -n32" ;; *64-bit*) LD="${LD-ld} -64" ;; esac fi fi rm -rf conftest* ;; x86_64-*kfreebsd*-gnu|x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*| \ s390*-*linux*|s390*-*tpf*|sparc*-*linux*) # Find out which ABI we are using. echo 'int i;' > conftest.$ac_ext if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 (eval $ac_compile) 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then case `/usr/bin/file conftest.o` in *32-bit*) case $host in x86_64-*kfreebsd*-gnu) LD="${LD-ld} -m elf_i386_fbsd" ;; x86_64-*linux*) LD="${LD-ld} -m elf_i386" ;; ppc64-*linux*|powerpc64-*linux*) LD="${LD-ld} -m elf32ppclinux" ;; s390x-*linux*) LD="${LD-ld} -m elf_s390" ;; sparc64-*linux*) LD="${LD-ld} -m elf32_sparc" ;; esac ;; *64-bit*) case $host in x86_64-*kfreebsd*-gnu) LD="${LD-ld} -m elf_x86_64_fbsd" ;; x86_64-*linux*) LD="${LD-ld} -m elf_x86_64" ;; ppc*-*linux*|powerpc*-*linux*) LD="${LD-ld} -m elf64ppc" ;; s390*-*linux*|s390*-*tpf*) LD="${LD-ld} -m elf64_s390" ;; sparc*-*linux*) LD="${LD-ld} -m elf64_sparc" ;; esac ;; esac fi rm -rf conftest* ;; *-*-sco3.2v5*) # On SCO OpenServer 5, we need -belf to get full-featured binaries. SAVE_CFLAGS="$CFLAGS" CFLAGS="$CFLAGS -belf" { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler needs -belf" >&5 $as_echo_n "checking whether the C compiler needs -belf... " >&6; } if ${lt_cv_cc_needs_belf+:} false; then : $as_echo_n "(cached) " >&6 else ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : lt_cv_cc_needs_belf=yes else lt_cv_cc_needs_belf=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_cc_needs_belf" >&5 $as_echo "$lt_cv_cc_needs_belf" >&6; } if test x"$lt_cv_cc_needs_belf" != x"yes"; then # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf CFLAGS="$SAVE_CFLAGS" fi ;; sparc*-*solaris*) # Find out which ABI we are using. echo 'int i;' > conftest.$ac_ext if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 (eval $ac_compile) 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then case `/usr/bin/file conftest.o` in *64-bit*) case $lt_cv_prog_gnu_ld in yes*) LD="${LD-ld} -m elf64_sparc" ;; *) if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then LD="${LD-ld} -64" fi ;; esac ;; esac fi rm -rf conftest* ;; esac need_locks="$enable_libtool_lock" if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}mt", so it can be a program name with args. set dummy ${ac_tool_prefix}mt; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_MANIFEST_TOOL+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$MANIFEST_TOOL"; then ac_cv_prog_MANIFEST_TOOL="$MANIFEST_TOOL" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_MANIFEST_TOOL="${ac_tool_prefix}mt" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi MANIFEST_TOOL=$ac_cv_prog_MANIFEST_TOOL if test -n "$MANIFEST_TOOL"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MANIFEST_TOOL" >&5 $as_echo "$MANIFEST_TOOL" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$ac_cv_prog_MANIFEST_TOOL"; then ac_ct_MANIFEST_TOOL=$MANIFEST_TOOL # Extract the first word of "mt", so it can be a program name with args. set dummy mt; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_MANIFEST_TOOL+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_MANIFEST_TOOL"; then ac_cv_prog_ac_ct_MANIFEST_TOOL="$ac_ct_MANIFEST_TOOL" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_MANIFEST_TOOL="mt" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_MANIFEST_TOOL=$ac_cv_prog_ac_ct_MANIFEST_TOOL if test -n "$ac_ct_MANIFEST_TOOL"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_MANIFEST_TOOL" >&5 $as_echo "$ac_ct_MANIFEST_TOOL" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test "x$ac_ct_MANIFEST_TOOL" = x; then MANIFEST_TOOL=":" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac MANIFEST_TOOL=$ac_ct_MANIFEST_TOOL fi else MANIFEST_TOOL="$ac_cv_prog_MANIFEST_TOOL" fi test -z "$MANIFEST_TOOL" && MANIFEST_TOOL=mt { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $MANIFEST_TOOL is a manifest tool" >&5 $as_echo_n "checking if $MANIFEST_TOOL is a manifest tool... " >&6; } if ${lt_cv_path_mainfest_tool+:} false; then : $as_echo_n "(cached) " >&6 else lt_cv_path_mainfest_tool=no echo "$as_me:$LINENO: $MANIFEST_TOOL '-?'" >&5 $MANIFEST_TOOL '-?' 2>conftest.err > conftest.out cat conftest.err >&5 if $GREP 'Manifest Tool' conftest.out > /dev/null; then lt_cv_path_mainfest_tool=yes fi rm -f conftest* fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_mainfest_tool" >&5 $as_echo "$lt_cv_path_mainfest_tool" >&6; } if test "x$lt_cv_path_mainfest_tool" != xyes; then MANIFEST_TOOL=: fi case $host_os in rhapsody* | darwin*) if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}dsymutil", so it can be a program name with args. set dummy ${ac_tool_prefix}dsymutil; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_DSYMUTIL+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$DSYMUTIL"; then ac_cv_prog_DSYMUTIL="$DSYMUTIL" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_DSYMUTIL="${ac_tool_prefix}dsymutil" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi DSYMUTIL=$ac_cv_prog_DSYMUTIL if test -n "$DSYMUTIL"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5 $as_echo "$DSYMUTIL" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$ac_cv_prog_DSYMUTIL"; then ac_ct_DSYMUTIL=$DSYMUTIL # Extract the first word of "dsymutil", so it can be a program name with args. set dummy dsymutil; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_DSYMUTIL+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_DSYMUTIL"; then ac_cv_prog_ac_ct_DSYMUTIL="$ac_ct_DSYMUTIL" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_DSYMUTIL="dsymutil" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_DSYMUTIL=$ac_cv_prog_ac_ct_DSYMUTIL if test -n "$ac_ct_DSYMUTIL"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DSYMUTIL" >&5 $as_echo "$ac_ct_DSYMUTIL" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test "x$ac_ct_DSYMUTIL" = x; then DSYMUTIL=":" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac DSYMUTIL=$ac_ct_DSYMUTIL fi else DSYMUTIL="$ac_cv_prog_DSYMUTIL" fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}nmedit", so it can be a program name with args. set dummy ${ac_tool_prefix}nmedit; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_NMEDIT+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$NMEDIT"; then ac_cv_prog_NMEDIT="$NMEDIT" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_NMEDIT="${ac_tool_prefix}nmedit" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi NMEDIT=$ac_cv_prog_NMEDIT if test -n "$NMEDIT"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NMEDIT" >&5 $as_echo "$NMEDIT" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$ac_cv_prog_NMEDIT"; then ac_ct_NMEDIT=$NMEDIT # Extract the first word of "nmedit", so it can be a program name with args. set dummy nmedit; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_NMEDIT+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_NMEDIT"; then ac_cv_prog_ac_ct_NMEDIT="$ac_ct_NMEDIT" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_NMEDIT="nmedit" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_NMEDIT=$ac_cv_prog_ac_ct_NMEDIT if test -n "$ac_ct_NMEDIT"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NMEDIT" >&5 $as_echo "$ac_ct_NMEDIT" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test "x$ac_ct_NMEDIT" = x; then NMEDIT=":" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac NMEDIT=$ac_ct_NMEDIT fi else NMEDIT="$ac_cv_prog_NMEDIT" fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}lipo", so it can be a program name with args. set dummy ${ac_tool_prefix}lipo; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_LIPO+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$LIPO"; then ac_cv_prog_LIPO="$LIPO" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_LIPO="${ac_tool_prefix}lipo" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi LIPO=$ac_cv_prog_LIPO if test -n "$LIPO"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5 $as_echo "$LIPO" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$ac_cv_prog_LIPO"; then ac_ct_LIPO=$LIPO # Extract the first word of "lipo", so it can be a program name with args. set dummy lipo; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_LIPO+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_LIPO"; then ac_cv_prog_ac_ct_LIPO="$ac_ct_LIPO" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_LIPO="lipo" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_LIPO=$ac_cv_prog_ac_ct_LIPO if test -n "$ac_ct_LIPO"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_LIPO" >&5 $as_echo "$ac_ct_LIPO" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test "x$ac_ct_LIPO" = x; then LIPO=":" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac LIPO=$ac_ct_LIPO fi else LIPO="$ac_cv_prog_LIPO" fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}otool", so it can be a program name with args. set dummy ${ac_tool_prefix}otool; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_OTOOL+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$OTOOL"; then ac_cv_prog_OTOOL="$OTOOL" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_OTOOL="${ac_tool_prefix}otool" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi OTOOL=$ac_cv_prog_OTOOL if test -n "$OTOOL"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5 $as_echo "$OTOOL" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$ac_cv_prog_OTOOL"; then ac_ct_OTOOL=$OTOOL # Extract the first word of "otool", so it can be a program name with args. set dummy otool; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_OTOOL+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_OTOOL"; then ac_cv_prog_ac_ct_OTOOL="$ac_ct_OTOOL" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OTOOL="otool" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_OTOOL=$ac_cv_prog_ac_ct_OTOOL if test -n "$ac_ct_OTOOL"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL" >&5 $as_echo "$ac_ct_OTOOL" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test "x$ac_ct_OTOOL" = x; then OTOOL=":" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac OTOOL=$ac_ct_OTOOL fi else OTOOL="$ac_cv_prog_OTOOL" fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}otool64", so it can be a program name with args. set dummy ${ac_tool_prefix}otool64; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_OTOOL64+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$OTOOL64"; then ac_cv_prog_OTOOL64="$OTOOL64" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_OTOOL64="${ac_tool_prefix}otool64" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi OTOOL64=$ac_cv_prog_OTOOL64 if test -n "$OTOOL64"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL64" >&5 $as_echo "$OTOOL64" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$ac_cv_prog_OTOOL64"; then ac_ct_OTOOL64=$OTOOL64 # Extract the first word of "otool64", so it can be a program name with args. set dummy otool64; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_OTOOL64+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_OTOOL64"; then ac_cv_prog_ac_ct_OTOOL64="$ac_ct_OTOOL64" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OTOOL64="otool64" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_OTOOL64=$ac_cv_prog_ac_ct_OTOOL64 if test -n "$ac_ct_OTOOL64"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL64" >&5 $as_echo "$ac_ct_OTOOL64" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test "x$ac_ct_OTOOL64" = x; then OTOOL64=":" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac OTOOL64=$ac_ct_OTOOL64 fi else OTOOL64="$ac_cv_prog_OTOOL64" fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -single_module linker flag" >&5 $as_echo_n "checking for -single_module linker flag... " >&6; } if ${lt_cv_apple_cc_single_mod+:} false; then : $as_echo_n "(cached) " >&6 else lt_cv_apple_cc_single_mod=no if test -z "${LT_MULTI_MODULE}"; then # By default we will add the -single_module flag. You can override # by either setting the environment variable LT_MULTI_MODULE # non-empty at configure time, or by adding -multi_module to the # link flags. rm -rf libconftest.dylib* echo "int foo(void){return 1;}" > conftest.c echo "$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \ -dynamiclib -Wl,-single_module conftest.c" >&5 $LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \ -dynamiclib -Wl,-single_module conftest.c 2>conftest.err _lt_result=$? if test -f libconftest.dylib && test ! -s conftest.err && test $_lt_result = 0; then lt_cv_apple_cc_single_mod=yes else cat conftest.err >&5 fi rm -rf libconftest.dylib* rm -f conftest.* fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_apple_cc_single_mod" >&5 $as_echo "$lt_cv_apple_cc_single_mod" >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -exported_symbols_list linker flag" >&5 $as_echo_n "checking for -exported_symbols_list linker flag... " >&6; } if ${lt_cv_ld_exported_symbols_list+:} false; then : $as_echo_n "(cached) " >&6 else lt_cv_ld_exported_symbols_list=no save_LDFLAGS=$LDFLAGS echo "_main" > conftest.sym LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : lt_cv_ld_exported_symbols_list=yes else lt_cv_ld_exported_symbols_list=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LDFLAGS="$save_LDFLAGS" fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_exported_symbols_list" >&5 $as_echo "$lt_cv_ld_exported_symbols_list" >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -force_load linker flag" >&5 $as_echo_n "checking for -force_load linker flag... " >&6; } if ${lt_cv_ld_force_load+:} false; then : $as_echo_n "(cached) " >&6 else lt_cv_ld_force_load=no cat > conftest.c << _LT_EOF int forced_loaded() { return 2;} _LT_EOF echo "$LTCC $LTCFLAGS -c -o conftest.o conftest.c" >&5 $LTCC $LTCFLAGS -c -o conftest.o conftest.c 2>&5 echo "$AR cru libconftest.a conftest.o" >&5 $AR cru libconftest.a conftest.o 2>&5 echo "$RANLIB libconftest.a" >&5 $RANLIB libconftest.a 2>&5 cat > conftest.c << _LT_EOF int main() { return 0;} _LT_EOF echo "$LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a" >&5 $LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a 2>conftest.err _lt_result=$? if test -f conftest && test ! -s conftest.err && test $_lt_result = 0 && $GREP forced_load conftest 2>&1 >/dev/null; then lt_cv_ld_force_load=yes else cat conftest.err >&5 fi rm -f conftest.err libconftest.a conftest conftest.c rm -rf conftest.dSYM fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_force_load" >&5 $as_echo "$lt_cv_ld_force_load" >&6; } case $host_os in rhapsody* | darwin1.[012]) _lt_dar_allow_undefined='${wl}-undefined ${wl}suppress' ;; darwin1.*) _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;; darwin*) # darwin 5.x on # if running on 10.5 or later, the deployment target defaults # to the OS version, if on x86, and 10.4, the deployment # target defaults to 10.4. Don't you love it? case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in 10.0,*86*-darwin8*|10.0,*-darwin[91]*) _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;; 10.[012]*) _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;; 10.*) _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;; esac ;; esac if test "$lt_cv_apple_cc_single_mod" = "yes"; then _lt_dar_single_mod='$single_module' fi if test "$lt_cv_ld_exported_symbols_list" = "yes"; then _lt_dar_export_syms=' ${wl}-exported_symbols_list,$output_objdir/${libname}-symbols.expsym' else _lt_dar_export_syms='~$NMEDIT -s $output_objdir/${libname}-symbols.expsym ${lib}' fi if test "$DSYMUTIL" != ":" && test "$lt_cv_ld_force_load" = "no"; then _lt_dsymutil='~$DSYMUTIL $lib || :' else _lt_dsymutil= fi ;; esac ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5 $as_echo_n "checking how to run the C preprocessor... " >&6; } # On Suns, sometimes $CPP names a directory. if test -n "$CPP" && test -d "$CPP"; then CPP= fi if test -z "$CPP"; then if ${ac_cv_prog_CPP+:} false; then : $as_echo_n "(cached) " >&6 else # Double quotes because CPP needs to be expanded for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" do ac_preproc_ok=false for ac_c_preproc_warn_flag in '' yes do # Use a header file that comes with gcc, so configuring glibc # with a fresh cross-compiler works. # Prefer to if __STDC__ is defined, since # exists even on freestanding compilers. # On the NeXT, cc -E runs the code through the compiler's parser, # not just through cpp. "Syntax error" is here to catch this case. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifdef __STDC__ # include #else # include #endif Syntax error _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : else # Broken: fails on valid input. continue fi rm -f conftest.err conftest.i conftest.$ac_ext # OK, works on sane cases. Now check whether nonexistent headers # can be detected and how. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : # Broken: success on invalid input. continue else # Passes both tests. ac_preproc_ok=: break fi rm -f conftest.err conftest.i conftest.$ac_ext done # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. rm -f conftest.i conftest.err conftest.$ac_ext if $ac_preproc_ok; then : break fi done ac_cv_prog_CPP=$CPP fi CPP=$ac_cv_prog_CPP else ac_cv_prog_CPP=$CPP fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5 $as_echo "$CPP" >&6; } ac_preproc_ok=false for ac_c_preproc_warn_flag in '' yes do # Use a header file that comes with gcc, so configuring glibc # with a fresh cross-compiler works. # Prefer to if __STDC__ is defined, since # exists even on freestanding compilers. # On the NeXT, cc -E runs the code through the compiler's parser, # not just through cpp. "Syntax error" is here to catch this case. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifdef __STDC__ # include #else # include #endif Syntax error _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : else # Broken: fails on valid input. continue fi rm -f conftest.err conftest.i conftest.$ac_ext # OK, works on sane cases. Now check whether nonexistent headers # can be detected and how. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : # Broken: success on invalid input. continue else # Passes both tests. ac_preproc_ok=: break fi rm -f conftest.err conftest.i conftest.$ac_ext done # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. rm -f conftest.i conftest.err conftest.$ac_ext if $ac_preproc_ok; then : else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "C preprocessor \"$CPP\" fails sanity check See \`config.log' for more details" "$LINENO" 5; } fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5 $as_echo_n "checking for ANSI C header files... " >&6; } if ${ac_cv_header_stdc+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #include #include int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_header_stdc=yes else ac_cv_header_stdc=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext if test $ac_cv_header_stdc = yes; then # SunOS 4.x string.h does not declare mem*, contrary to ANSI. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | $EGREP "memchr" >/dev/null 2>&1; then : else 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 confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | $EGREP "free" >/dev/null 2>&1; then : else 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 : : else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if ((' ' & 0x0FF) == 0x020) # define ISLOWER(c) ('a' <= (c) && (c) <= 'z') # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) #else # define ISLOWER(c) \ (('a' <= (c) && (c) <= 'i') \ || ('j' <= (c) && (c) <= 'r') \ || ('s' <= (c) && (c) <= 'z')) # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c)) #endif #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)) return 2; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : else ac_cv_header_stdc=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5 $as_echo "$ac_cv_header_stdc" >&6; } if test $ac_cv_header_stdc = yes; then $as_echo "#define STDC_HEADERS 1" >>confdefs.h fi # On IRIX 5.3, sys/types and inttypes.h are conflicting. for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \ inttypes.h stdint.h unistd.h do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default " if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 _ACEOF fi done for ac_header in dlfcn.h do : ac_fn_c_check_header_compile "$LINENO" "dlfcn.h" "ac_cv_header_dlfcn_h" "$ac_includes_default " if test "x$ac_cv_header_dlfcn_h" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_DLFCN_H 1 _ACEOF fi done # Set options # Check whether --enable-shared was given. if test "${enable_shared+set}" = set; then : enableval=$enable_shared; p=${PACKAGE-default} case $enableval in yes) enable_shared=yes ;; no) enable_shared=no ;; *) enable_shared=no # Look at the argument we got. We use all the common list separators. lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," for pkg in $enableval; do IFS="$lt_save_ifs" if test "X$pkg" = "X$p"; then enable_shared=yes fi done IFS="$lt_save_ifs" ;; esac else enable_shared=no fi enable_win32_dll=yes case $host in *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-cegcc*) if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args. set dummy ${ac_tool_prefix}as; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_AS+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$AS"; then ac_cv_prog_AS="$AS" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_AS="${ac_tool_prefix}as" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi AS=$ac_cv_prog_AS if test -n "$AS"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AS" >&5 $as_echo "$AS" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$ac_cv_prog_AS"; then ac_ct_AS=$AS # Extract the first word of "as", so it can be a program name with args. set dummy as; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_AS+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_AS"; then ac_cv_prog_ac_ct_AS="$ac_ct_AS" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_AS="as" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_AS=$ac_cv_prog_ac_ct_AS if test -n "$ac_ct_AS"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AS" >&5 $as_echo "$ac_ct_AS" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test "x$ac_ct_AS" = x; then AS="false" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac AS=$ac_ct_AS fi else AS="$ac_cv_prog_AS" fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}dlltool", so it can be a program name with args. set dummy ${ac_tool_prefix}dlltool; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_DLLTOOL+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$DLLTOOL"; then ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_DLLTOOL="${ac_tool_prefix}dlltool" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi DLLTOOL=$ac_cv_prog_DLLTOOL if test -n "$DLLTOOL"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5 $as_echo "$DLLTOOL" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$ac_cv_prog_DLLTOOL"; then ac_ct_DLLTOOL=$DLLTOOL # Extract the first word of "dlltool", so it can be a program name with args. set dummy dlltool; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_DLLTOOL+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_DLLTOOL"; then ac_cv_prog_ac_ct_DLLTOOL="$ac_ct_DLLTOOL" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_DLLTOOL="dlltool" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_DLLTOOL=$ac_cv_prog_ac_ct_DLLTOOL if test -n "$ac_ct_DLLTOOL"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5 $as_echo "$ac_ct_DLLTOOL" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test "x$ac_ct_DLLTOOL" = x; then DLLTOOL="false" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac DLLTOOL=$ac_ct_DLLTOOL fi else DLLTOOL="$ac_cv_prog_DLLTOOL" fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args. set dummy ${ac_tool_prefix}objdump; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_OBJDUMP+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$OBJDUMP"; then ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi OBJDUMP=$ac_cv_prog_OBJDUMP if test -n "$OBJDUMP"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5 $as_echo "$OBJDUMP" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$ac_cv_prog_OBJDUMP"; then ac_ct_OBJDUMP=$OBJDUMP # Extract the first word of "objdump", so it can be a program name with args. set dummy objdump; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_OBJDUMP+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_OBJDUMP"; then ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OBJDUMP="objdump" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP if test -n "$ac_ct_OBJDUMP"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5 $as_echo "$ac_ct_OBJDUMP" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test "x$ac_ct_OBJDUMP" = x; then OBJDUMP="false" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac OBJDUMP=$ac_ct_OBJDUMP fi else OBJDUMP="$ac_cv_prog_OBJDUMP" fi ;; esac test -z "$AS" && AS=as test -z "$DLLTOOL" && DLLTOOL=dlltool test -z "$OBJDUMP" && OBJDUMP=objdump enable_dlopen=no # Check whether --enable-static was given. if test "${enable_static+set}" = set; then : enableval=$enable_static; p=${PACKAGE-default} case $enableval in yes) enable_static=yes ;; no) enable_static=no ;; *) enable_static=no # Look at the argument we got. We use all the common list separators. lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," for pkg in $enableval; do IFS="$lt_save_ifs" if test "X$pkg" = "X$p"; then enable_static=yes fi done IFS="$lt_save_ifs" ;; esac else enable_static=yes fi # Check whether --with-pic was given. if test "${with_pic+set}" = set; then : withval=$with_pic; pic_mode="$withval" else pic_mode=default fi test -z "$pic_mode" && pic_mode=default # Check whether --enable-fast-install was given. if test "${enable_fast_install+set}" = set; then : enableval=$enable_fast_install; p=${PACKAGE-default} case $enableval in yes) enable_fast_install=yes ;; no) enable_fast_install=no ;; *) enable_fast_install=no # Look at the argument we got. We use all the common list separators. lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," for pkg in $enableval; do IFS="$lt_save_ifs" if test "X$pkg" = "X$p"; then enable_fast_install=yes fi done IFS="$lt_save_ifs" ;; esac else enable_fast_install=yes fi # This can be used to rebuild libtool when needed LIBTOOL_DEPS="$ltmain" # Always use our own libtool. LIBTOOL='$(SHELL) $(top_builddir)/libtool' test -z "$LN_S" && LN_S="ln -s" if test -n "${ZSH_VERSION+set}" ; then setopt NO_GLOB_SUBST fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for objdir" >&5 $as_echo_n "checking for objdir... " >&6; } if ${lt_cv_objdir+:} false; then : $as_echo_n "(cached) " >&6 else rm -f .libs 2>/dev/null mkdir .libs 2>/dev/null if test -d .libs; then lt_cv_objdir=.libs else # MS-DOS does not allow filenames that begin with a dot. lt_cv_objdir=_libs fi rmdir .libs 2>/dev/null fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_objdir" >&5 $as_echo "$lt_cv_objdir" >&6; } objdir=$lt_cv_objdir cat >>confdefs.h <<_ACEOF #define LT_OBJDIR "$lt_cv_objdir/" _ACEOF case $host_os in aix3*) # AIX sometimes has problems with the GCC collect2 program. For some # reason, if we set the COLLECT_NAMES environment variable, the problems # vanish in a puff of smoke. if test "X${COLLECT_NAMES+set}" != Xset; then COLLECT_NAMES= export COLLECT_NAMES fi ;; esac # Global variables: ofile=libtool can_build_shared=yes # All known linkers require a `.a' archive for static linking (except MSVC, # which needs '.lib'). libext=a with_gnu_ld="$lt_cv_prog_gnu_ld" old_CC="$CC" old_CFLAGS="$CFLAGS" # Set sane defaults for various variables test -z "$CC" && CC=cc test -z "$LTCC" && LTCC=$CC test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS test -z "$LD" && LD=ld test -z "$ac_objext" && ac_objext=o for cc_temp in $compiler""; do case $cc_temp in compile | *[\\/]compile | ccache | *[\\/]ccache ) ;; distcc | *[\\/]distcc | purify | *[\\/]purify ) ;; \-*) ;; *) break;; esac done cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"` # Only perform the check for file, if the check method requires it test -z "$MAGIC_CMD" && MAGIC_CMD=file case $deplibs_check_method in file_magic*) if test "$file_magic_cmd" = '$MAGIC_CMD'; then { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ac_tool_prefix}file" >&5 $as_echo_n "checking for ${ac_tool_prefix}file... " >&6; } if ${lt_cv_path_MAGIC_CMD+:} false; then : $as_echo_n "(cached) " >&6 else case $MAGIC_CMD in [\\/*] | ?:[\\/]*) lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path. ;; *) lt_save_MAGIC_CMD="$MAGIC_CMD" lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR ac_dummy="/usr/bin$PATH_SEPARATOR$PATH" for ac_dir in $ac_dummy; do IFS="$lt_save_ifs" test -z "$ac_dir" && ac_dir=. if test -f $ac_dir/${ac_tool_prefix}file; then lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file" if test -n "$file_magic_test_file"; then case $deplibs_check_method in "file_magic "*) file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"` MAGIC_CMD="$lt_cv_path_MAGIC_CMD" if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null | $EGREP "$file_magic_regex" > /dev/null; then : else cat <<_LT_EOF 1>&2 *** Warning: the command libtool uses to detect shared libraries, *** $file_magic_cmd, produces output that libtool cannot recognize. *** The result is that libtool may fail to recognize shared libraries *** as such. This will affect the creation of libtool libraries that *** depend on shared libraries, but programs linked with such libtool *** libraries will work regardless of this problem. Nevertheless, you *** may want to report the problem to your system manager and/or to *** bug-libtool@gnu.org _LT_EOF fi ;; esac fi break fi done IFS="$lt_save_ifs" MAGIC_CMD="$lt_save_MAGIC_CMD" ;; esac fi MAGIC_CMD="$lt_cv_path_MAGIC_CMD" if test -n "$MAGIC_CMD"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5 $as_echo "$MAGIC_CMD" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test -z "$lt_cv_path_MAGIC_CMD"; then if test -n "$ac_tool_prefix"; then { $as_echo "$as_me:${as_lineno-$LINENO}: checking for file" >&5 $as_echo_n "checking for file... " >&6; } if ${lt_cv_path_MAGIC_CMD+:} false; then : $as_echo_n "(cached) " >&6 else case $MAGIC_CMD in [\\/*] | ?:[\\/]*) lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path. ;; *) lt_save_MAGIC_CMD="$MAGIC_CMD" lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR ac_dummy="/usr/bin$PATH_SEPARATOR$PATH" for ac_dir in $ac_dummy; do IFS="$lt_save_ifs" test -z "$ac_dir" && ac_dir=. if test -f $ac_dir/file; then lt_cv_path_MAGIC_CMD="$ac_dir/file" if test -n "$file_magic_test_file"; then case $deplibs_check_method in "file_magic "*) file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"` MAGIC_CMD="$lt_cv_path_MAGIC_CMD" if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null | $EGREP "$file_magic_regex" > /dev/null; then : else cat <<_LT_EOF 1>&2 *** Warning: the command libtool uses to detect shared libraries, *** $file_magic_cmd, produces output that libtool cannot recognize. *** The result is that libtool may fail to recognize shared libraries *** as such. This will affect the creation of libtool libraries that *** depend on shared libraries, but programs linked with such libtool *** libraries will work regardless of this problem. Nevertheless, you *** may want to report the problem to your system manager and/or to *** bug-libtool@gnu.org _LT_EOF fi ;; esac fi break fi done IFS="$lt_save_ifs" MAGIC_CMD="$lt_save_MAGIC_CMD" ;; esac fi MAGIC_CMD="$lt_cv_path_MAGIC_CMD" if test -n "$MAGIC_CMD"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5 $as_echo "$MAGIC_CMD" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi else MAGIC_CMD=: fi fi fi ;; esac # Use C for the default configuration in the libtool script lt_save_CC="$CC" ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu # Source file extension for C test sources. ac_ext=c # Object file extension for compiled C test sources. objext=o objext=$objext # Code to be used in simple compile tests lt_simple_compile_test_code="int some_variable = 0;" # Code to be used in simple link tests lt_simple_link_test_code='int main(){return(0);}' # If no C compiler was specified, use CC. LTCC=${LTCC-"$CC"} # If no C compiler flags were specified, use CFLAGS. LTCFLAGS=${LTCFLAGS-"$CFLAGS"} # Allow CC to be a program name with arguments. compiler=$CC # Save the default compiler, since it gets overwritten when the other # tags are being tested, and _LT_TAGVAR(compiler, []) is a NOP. compiler_DEFAULT=$CC # save warnings/boilerplate of simple test code ac_outfile=conftest.$ac_objext echo "$lt_simple_compile_test_code" >conftest.$ac_ext eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err _lt_compiler_boilerplate=`cat conftest.err` $RM conftest* ac_outfile=conftest.$ac_objext echo "$lt_simple_link_test_code" >conftest.$ac_ext eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err _lt_linker_boilerplate=`cat conftest.err` $RM -r conftest* ## CAVEAT EMPTOR: ## There is no encapsulation within the following macros, do not change ## the running order or otherwise move them around unless you know exactly ## what you are doing... if test -n "$compiler"; then lt_prog_compiler_no_builtin_flag= if test "$GCC" = yes; then case $cc_basename in nvcc*) lt_prog_compiler_no_builtin_flag=' -Xcompiler -fno-builtin' ;; *) lt_prog_compiler_no_builtin_flag=' -fno-builtin' ;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -fno-rtti -fno-exceptions" >&5 $as_echo_n "checking if $compiler supports -fno-rtti -fno-exceptions... " >&6; } if ${lt_cv_prog_compiler_rtti_exceptions+:} false; then : $as_echo_n "(cached) " >&6 else lt_cv_prog_compiler_rtti_exceptions=no ac_outfile=conftest.$ac_objext echo "$lt_simple_compile_test_code" > conftest.$ac_ext lt_compiler_flag="-fno-rtti -fno-exceptions" # Insert the option either (1) after the last *FLAGS variable, or # (2) before a word containing "conftest.", or (3) at the end. # Note that $ac_compile itself does not contain backslashes and begins # with a dollar sign (not a hyphen), so the echo should work correctly. # The option is referenced via a variable to avoid confusing sed. lt_compile=`echo "$ac_compile" | $SED \ -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ -e 's:$: $lt_compiler_flag:'` (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5) (eval "$lt_compile" 2>conftest.err) ac_status=$? cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 if (exit $ac_status) && test -s "$ac_outfile"; then # The compiler can only warn and ignore the option if not recognized # So say no if there are warnings other than the usual output. $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then lt_cv_prog_compiler_rtti_exceptions=yes fi fi $RM conftest* fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_rtti_exceptions" >&5 $as_echo "$lt_cv_prog_compiler_rtti_exceptions" >&6; } if test x"$lt_cv_prog_compiler_rtti_exceptions" = xyes; then lt_prog_compiler_no_builtin_flag="$lt_prog_compiler_no_builtin_flag -fno-rtti -fno-exceptions" else : fi fi lt_prog_compiler_wl= lt_prog_compiler_pic= lt_prog_compiler_static= if test "$GCC" = yes; then lt_prog_compiler_wl='-Wl,' lt_prog_compiler_static='-static' case $host_os in aix*) # All AIX code is PIC. if test "$host_cpu" = ia64; then # AIX 5 now supports IA64 processor lt_prog_compiler_static='-Bstatic' fi ;; amigaos*) case $host_cpu in powerpc) # see comment about AmigaOS4 .so support lt_prog_compiler_pic='-fPIC' ;; m68k) # FIXME: we need at least 68020 code to build shared libraries, but # adding the `-m68020' flag to GCC prevents building anything better, # like `-m68040'. lt_prog_compiler_pic='-m68020 -resident32 -malways-restore-a4' ;; esac ;; beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*) # PIC is the default for these OSes. ;; mingw* | cygwin* | pw32* | os2* | cegcc*) # This hack is so that the source file can tell whether it is being # built for inclusion in a dll (and should export symbols for example). # Although the cygwin gcc ignores -fPIC, still need this for old-style # (--disable-auto-import) libraries lt_prog_compiler_pic='-DDLL_EXPORT' ;; darwin* | rhapsody*) # PIC is the default on this platform # Common symbols not allowed in MH_DYLIB files lt_prog_compiler_pic='-fno-common' ;; haiku*) # PIC is the default for Haiku. # The "-static" flag exists, but is broken. lt_prog_compiler_static= ;; hpux*) # PIC is the default for 64-bit PA HP-UX, but not for 32-bit # PA HP-UX. On IA64 HP-UX, PIC is the default but the pic flag # sets the default TLS model and affects inlining. case $host_cpu in hppa*64*) # +Z the default ;; *) lt_prog_compiler_pic='-fPIC' ;; esac ;; interix[3-9]*) # Interix 3.x gcc -fpic/-fPIC options generate broken code. # Instead, we relocate shared libraries at runtime. ;; msdosdjgpp*) # Just because we use GCC doesn't mean we suddenly get shared libraries # on systems that don't support them. lt_prog_compiler_can_build_shared=no enable_shared=no ;; *nto* | *qnx*) # QNX uses GNU C++, but need to define -shared option too, otherwise # it will coredump. lt_prog_compiler_pic='-fPIC -shared' ;; sysv4*MP*) if test -d /usr/nec; then lt_prog_compiler_pic=-Kconform_pic fi ;; *) lt_prog_compiler_pic='-fPIC' ;; esac case $cc_basename in nvcc*) # Cuda Compiler Driver 2.2 lt_prog_compiler_wl='-Xlinker ' lt_prog_compiler_pic='-Xcompiler -fPIC' ;; esac else # PORTME Check for flag to pass linker flags through the system compiler. case $host_os in aix*) lt_prog_compiler_wl='-Wl,' if test "$host_cpu" = ia64; then # AIX 5 now supports IA64 processor lt_prog_compiler_static='-Bstatic' else lt_prog_compiler_static='-bnso -bI:/lib/syscalls.exp' fi ;; mingw* | cygwin* | pw32* | os2* | cegcc*) # This hack is so that the source file can tell whether it is being # built for inclusion in a dll (and should export symbols for example). lt_prog_compiler_pic='-DDLL_EXPORT' ;; hpux9* | hpux10* | hpux11*) lt_prog_compiler_wl='-Wl,' # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but # not for PA HP-UX. case $host_cpu in hppa*64*|ia64*) # +Z the default ;; *) lt_prog_compiler_pic='+Z' ;; esac # Is there a better lt_prog_compiler_static that works with the bundled CC? lt_prog_compiler_static='${wl}-a ${wl}archive' ;; irix5* | irix6* | nonstopux*) lt_prog_compiler_wl='-Wl,' # PIC (with -KPIC) is the default. lt_prog_compiler_static='-non_shared' ;; linux* | k*bsd*-gnu | kopensolaris*-gnu) case $cc_basename in # old Intel for x86_64 which still supported -KPIC. ecc*) lt_prog_compiler_wl='-Wl,' lt_prog_compiler_pic='-KPIC' lt_prog_compiler_static='-static' ;; # icc used to be incompatible with GCC. # ICC 10 doesn't accept -KPIC any more. icc* | ifort*) lt_prog_compiler_wl='-Wl,' lt_prog_compiler_pic='-fPIC' lt_prog_compiler_static='-static' ;; # Lahey Fortran 8.1. lf95*) lt_prog_compiler_wl='-Wl,' lt_prog_compiler_pic='--shared' lt_prog_compiler_static='--static' ;; nagfor*) # NAG Fortran compiler lt_prog_compiler_wl='-Wl,-Wl,,' lt_prog_compiler_pic='-PIC' lt_prog_compiler_static='-Bstatic' ;; pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*) # Portland Group compilers (*not* the Pentium gcc compiler, # which looks to be a dead project) lt_prog_compiler_wl='-Wl,' lt_prog_compiler_pic='-fpic' lt_prog_compiler_static='-Bstatic' ;; ccc*) lt_prog_compiler_wl='-Wl,' # All Alpha code is PIC. lt_prog_compiler_static='-non_shared' ;; xl* | bgxl* | bgf* | mpixl*) # IBM XL C 8.0/Fortran 10.1, 11.1 on PPC and BlueGene lt_prog_compiler_wl='-Wl,' lt_prog_compiler_pic='-qpic' lt_prog_compiler_static='-qstaticlink' ;; *) case `$CC -V 2>&1 | sed 5q` in *Sun\ F* | *Sun*Fortran*) # Sun Fortran 8.3 passes all unrecognized flags to the linker lt_prog_compiler_pic='-KPIC' lt_prog_compiler_static='-Bstatic' lt_prog_compiler_wl='' ;; *Sun\ C*) # Sun C 5.9 lt_prog_compiler_pic='-KPIC' lt_prog_compiler_static='-Bstatic' lt_prog_compiler_wl='-Wl,' ;; esac ;; esac ;; newsos6) lt_prog_compiler_pic='-KPIC' lt_prog_compiler_static='-Bstatic' ;; *nto* | *qnx*) # QNX uses GNU C++, but need to define -shared option too, otherwise # it will coredump. lt_prog_compiler_pic='-fPIC -shared' ;; osf3* | osf4* | osf5*) lt_prog_compiler_wl='-Wl,' # All OSF/1 code is PIC. lt_prog_compiler_static='-non_shared' ;; rdos*) lt_prog_compiler_static='-non_shared' ;; solaris*) lt_prog_compiler_pic='-KPIC' lt_prog_compiler_static='-Bstatic' case $cc_basename in f77* | f90* | f95* | sunf77* | sunf90* | sunf95*) lt_prog_compiler_wl='-Qoption ld ';; *) lt_prog_compiler_wl='-Wl,';; esac ;; sunos4*) lt_prog_compiler_wl='-Qoption ld ' lt_prog_compiler_pic='-PIC' lt_prog_compiler_static='-Bstatic' ;; sysv4 | sysv4.2uw2* | sysv4.3*) lt_prog_compiler_wl='-Wl,' lt_prog_compiler_pic='-KPIC' lt_prog_compiler_static='-Bstatic' ;; sysv4*MP*) if test -d /usr/nec ;then lt_prog_compiler_pic='-Kconform_pic' lt_prog_compiler_static='-Bstatic' fi ;; sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*) lt_prog_compiler_wl='-Wl,' lt_prog_compiler_pic='-KPIC' lt_prog_compiler_static='-Bstatic' ;; unicos*) lt_prog_compiler_wl='-Wl,' lt_prog_compiler_can_build_shared=no ;; uts4*) lt_prog_compiler_pic='-pic' lt_prog_compiler_static='-Bstatic' ;; *) lt_prog_compiler_can_build_shared=no ;; esac fi case $host_os in # For platforms which do not support PIC, -DPIC is meaningless: *djgpp*) lt_prog_compiler_pic= ;; *) lt_prog_compiler_pic="$lt_prog_compiler_pic -DPIC" ;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5 $as_echo_n "checking for $compiler option to produce PIC... " >&6; } if ${lt_cv_prog_compiler_pic+:} false; then : $as_echo_n "(cached) " >&6 else lt_cv_prog_compiler_pic=$lt_prog_compiler_pic fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic" >&5 $as_echo "$lt_cv_prog_compiler_pic" >&6; } lt_prog_compiler_pic=$lt_cv_prog_compiler_pic # # Check to make sure the PIC flag actually works. # if test -n "$lt_prog_compiler_pic"; then { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5 $as_echo_n "checking if $compiler PIC flag $lt_prog_compiler_pic works... " >&6; } if ${lt_cv_prog_compiler_pic_works+:} false; then : $as_echo_n "(cached) " >&6 else lt_cv_prog_compiler_pic_works=no ac_outfile=conftest.$ac_objext echo "$lt_simple_compile_test_code" > conftest.$ac_ext lt_compiler_flag="$lt_prog_compiler_pic -DPIC" # Insert the option either (1) after the last *FLAGS variable, or # (2) before a word containing "conftest.", or (3) at the end. # Note that $ac_compile itself does not contain backslashes and begins # with a dollar sign (not a hyphen), so the echo should work correctly. # The option is referenced via a variable to avoid confusing sed. lt_compile=`echo "$ac_compile" | $SED \ -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ -e 's:$: $lt_compiler_flag:'` (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5) (eval "$lt_compile" 2>conftest.err) ac_status=$? cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 if (exit $ac_status) && test -s "$ac_outfile"; then # The compiler can only warn and ignore the option if not recognized # So say no if there are warnings other than the usual output. $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then lt_cv_prog_compiler_pic_works=yes fi fi $RM conftest* fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works" >&5 $as_echo "$lt_cv_prog_compiler_pic_works" >&6; } if test x"$lt_cv_prog_compiler_pic_works" = xyes; then case $lt_prog_compiler_pic in "" | " "*) ;; *) lt_prog_compiler_pic=" $lt_prog_compiler_pic" ;; esac else lt_prog_compiler_pic= lt_prog_compiler_can_build_shared=no fi fi # # Check to make sure the static flag actually works. # wl=$lt_prog_compiler_wl eval lt_tmp_static_flag=\"$lt_prog_compiler_static\" { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5 $as_echo_n "checking if $compiler static flag $lt_tmp_static_flag works... " >&6; } if ${lt_cv_prog_compiler_static_works+:} false; then : $as_echo_n "(cached) " >&6 else lt_cv_prog_compiler_static_works=no save_LDFLAGS="$LDFLAGS" LDFLAGS="$LDFLAGS $lt_tmp_static_flag" echo "$lt_simple_link_test_code" > conftest.$ac_ext if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then # The linker can only warn and ignore the option if not recognized # So say no if there are warnings if test -s conftest.err; then # Append any errors to the config.log. cat conftest.err 1>&5 $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 if diff conftest.exp conftest.er2 >/dev/null; then lt_cv_prog_compiler_static_works=yes fi else lt_cv_prog_compiler_static_works=yes fi fi $RM -r conftest* LDFLAGS="$save_LDFLAGS" fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works" >&5 $as_echo "$lt_cv_prog_compiler_static_works" >&6; } if test x"$lt_cv_prog_compiler_static_works" = xyes; then : else lt_prog_compiler_static= fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 $as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; } if ${lt_cv_prog_compiler_c_o+:} false; then : $as_echo_n "(cached) " >&6 else lt_cv_prog_compiler_c_o=no $RM -r conftest 2>/dev/null mkdir conftest cd conftest mkdir out echo "$lt_simple_compile_test_code" > conftest.$ac_ext lt_compiler_flag="-o out/conftest2.$ac_objext" # Insert the option either (1) after the last *FLAGS variable, or # (2) before a word containing "conftest.", or (3) at the end. # Note that $ac_compile itself does not contain backslashes and begins # with a dollar sign (not a hyphen), so the echo should work correctly. lt_compile=`echo "$ac_compile" | $SED \ -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ -e 's:$: $lt_compiler_flag:'` (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5) (eval "$lt_compile" 2>out/conftest.err) ac_status=$? cat out/conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 if (exit $ac_status) && test -s out/conftest2.$ac_objext then # The compiler can only warn and ignore the option if not recognized # So say no if there are warnings $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2 if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then lt_cv_prog_compiler_c_o=yes fi fi chmod u+w . 2>&5 $RM conftest* # SGI C++ compiler will create directory out/ii_files/ for # template instantiation test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files $RM out/* && rmdir out cd .. $RM -r conftest $RM conftest* fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5 $as_echo "$lt_cv_prog_compiler_c_o" >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 $as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; } if ${lt_cv_prog_compiler_c_o+:} false; then : $as_echo_n "(cached) " >&6 else lt_cv_prog_compiler_c_o=no $RM -r conftest 2>/dev/null mkdir conftest cd conftest mkdir out echo "$lt_simple_compile_test_code" > conftest.$ac_ext lt_compiler_flag="-o out/conftest2.$ac_objext" # Insert the option either (1) after the last *FLAGS variable, or # (2) before a word containing "conftest.", or (3) at the end. # Note that $ac_compile itself does not contain backslashes and begins # with a dollar sign (not a hyphen), so the echo should work correctly. lt_compile=`echo "$ac_compile" | $SED \ -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ -e 's:$: $lt_compiler_flag:'` (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5) (eval "$lt_compile" 2>out/conftest.err) ac_status=$? cat out/conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 if (exit $ac_status) && test -s out/conftest2.$ac_objext then # The compiler can only warn and ignore the option if not recognized # So say no if there are warnings $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2 if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then lt_cv_prog_compiler_c_o=yes fi fi chmod u+w . 2>&5 $RM conftest* # SGI C++ compiler will create directory out/ii_files/ for # template instantiation test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files $RM out/* && rmdir out cd .. $RM -r conftest $RM conftest* fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5 $as_echo "$lt_cv_prog_compiler_c_o" >&6; } hard_links="nottested" if test "$lt_cv_prog_compiler_c_o" = no && test "$need_locks" != no; then # do not overwrite the value of need_locks provided by the user { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5 $as_echo_n "checking if we can lock with hard links... " >&6; } hard_links=yes $RM conftest* ln conftest.a conftest.b 2>/dev/null && hard_links=no touch conftest.a ln conftest.a conftest.b 2>&5 || hard_links=no ln conftest.a conftest.b 2>/dev/null && hard_links=no { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5 $as_echo "$hard_links" >&6; } if test "$hard_links" = no; then { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5 $as_echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;} need_locks=warn fi else need_locks=no fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 $as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; } runpath_var= allow_undefined_flag= always_export_symbols=no archive_cmds= archive_expsym_cmds= compiler_needs_object=no enable_shared_with_static_runtimes=no export_dynamic_flag_spec= export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' hardcode_automatic=no hardcode_direct=no hardcode_direct_absolute=no hardcode_libdir_flag_spec= hardcode_libdir_flag_spec_ld= hardcode_libdir_separator= hardcode_minus_L=no hardcode_shlibpath_var=unsupported inherit_rpath=no link_all_deplibs=unknown module_cmds= module_expsym_cmds= old_archive_from_new_cmds= old_archive_from_expsyms_cmds= thread_safe_flag_spec= whole_archive_flag_spec= # include_expsyms should be a list of space-separated symbols to be *always* # included in the symbol list include_expsyms= # exclude_expsyms can be an extended regexp of symbols to exclude # it will be wrapped by ` (' and `)$', so one must not match beginning or # end of line. Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc', # as well as any symbol that contains `d'. exclude_expsyms='_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*' # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out # platforms (ab)use it in PIC code, but their linkers get confused if # the symbol is explicitly referenced. Since portable code cannot # rely on this symbol name, it's probably fine to never include it in # preloaded symbol tables. # Exclude shared library initialization/finalization symbols. extract_expsyms_cmds= case $host_os in cygwin* | mingw* | pw32* | cegcc*) # FIXME: the MSVC++ port hasn't been tested in a loooong time # When not using gcc, we currently assume that we are using # Microsoft Visual C++. if test "$GCC" != yes; then with_gnu_ld=no fi ;; interix*) # we just hope/assume this is gcc and not c89 (= MSVC++) with_gnu_ld=yes ;; openbsd*) with_gnu_ld=no ;; esac ld_shlibs=yes # On some targets, GNU ld is compatible enough with the native linker # that we're better off using the native interface for both. lt_use_gnu_ld_interface=no if test "$with_gnu_ld" = yes; then case $host_os in aix*) # The AIX port of GNU ld has always aspired to compatibility # with the native linker. However, as the warning in the GNU ld # block says, versions before 2.19.5* couldn't really create working # shared libraries, regardless of the interface used. case `$LD -v 2>&1` in *\ \(GNU\ Binutils\)\ 2.19.5*) ;; *\ \(GNU\ Binutils\)\ 2.[2-9]*) ;; *\ \(GNU\ Binutils\)\ [3-9]*) ;; *) lt_use_gnu_ld_interface=yes ;; esac ;; *) lt_use_gnu_ld_interface=yes ;; esac fi if test "$lt_use_gnu_ld_interface" = yes; then # If archive_cmds runs LD, not CC, wlarc should be empty wlarc='${wl}' # Set some defaults for GNU ld with shared library support. These # are reset later if shared libraries are not supported. Putting them # here allows them to be overridden if necessary. runpath_var=LD_RUN_PATH hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' export_dynamic_flag_spec='${wl}--export-dynamic' # ancient GNU ld didn't support --whole-archive et. al. if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then whole_archive_flag_spec="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' else whole_archive_flag_spec= fi supports_anon_versioning=no case `$LD -v 2>&1` in *GNU\ gold*) supports_anon_versioning=yes ;; *\ [01].* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11 *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ... *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ... *\ 2.11.*) ;; # other 2.11 versions *) supports_anon_versioning=yes ;; esac # See if GNU ld supports shared libraries. case $host_os in aix[3-9]*) # On AIX/PPC, the GNU linker is very broken if test "$host_cpu" != ia64; then ld_shlibs=no cat <<_LT_EOF 1>&2 *** Warning: the GNU linker, at least up to release 2.19, is reported *** to be unable to reliably create shared libraries on AIX. *** Therefore, libtool is disabling shared libraries support. If you *** really care for shared libraries, you may want to install binutils *** 2.20 or above, or modify your PATH so that a non-GNU linker is found. *** You will then need to restart the configuration process. _LT_EOF fi ;; amigaos*) case $host_cpu in powerpc) # see comment about AmigaOS4 .so support archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' archive_expsym_cmds='' ;; m68k) archive_cmds='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' hardcode_libdir_flag_spec='-L$libdir' hardcode_minus_L=yes ;; esac ;; beos*) if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then allow_undefined_flag=unsupported # Joseph Beckenbach says some releases of gcc # support --undefined. This deserves some investigation. FIXME archive_cmds='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' else ld_shlibs=no fi ;; cygwin* | mingw* | pw32* | cegcc*) # _LT_TAGVAR(hardcode_libdir_flag_spec, ) is actually meaningless, # as there is no search path for DLLs. hardcode_libdir_flag_spec='-L$libdir' export_dynamic_flag_spec='${wl}--export-all-symbols' allow_undefined_flag=unsupported always_export_symbols=no enable_shared_with_static_runtimes=yes export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1 DATA/;s/^.*[ ]__nm__\([^ ]*\)[ ][^ ]*/\1 DATA/;/^I[ ]/d;/^[AITW][ ]/s/.* //'\'' | sort | uniq > $export_symbols' exclude_expsyms='[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname' if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' # If the export-symbols file already is a .def file (1st line # is EXPORTS), use it as is; otherwise, prepend... archive_expsym_cmds='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then cp $export_symbols $output_objdir/$soname.def; else echo EXPORTS > $output_objdir/$soname.def; cat $export_symbols >> $output_objdir/$soname.def; fi~ $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' else ld_shlibs=no fi ;; haiku*) archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' link_all_deplibs=yes ;; interix[3-9]*) hardcode_direct=no hardcode_shlibpath_var=no hardcode_libdir_flag_spec='${wl}-rpath,$libdir' export_dynamic_flag_spec='${wl}-E' # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc. # Instead, shared libraries are loaded at an image base (0x10000000 by # default) and relocated if they conflict, which is a slow very memory # consuming and fragmenting process. To avoid this, we pick a random, # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link # time. Moving up from 0x10000000 also allows more sbrk(2) space. archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' archive_expsym_cmds='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' ;; gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu) tmp_diet=no if test "$host_os" = linux-dietlibc; then case $cc_basename in diet\ *) tmp_diet=yes;; # linux-dietlibc with static linking (!diet-dyn) esac fi if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \ && test "$tmp_diet" = no then tmp_addflag=' $pic_flag' tmp_sharedflag='-shared' case $cc_basename,$host_cpu in pgcc*) # Portland Group C compiler whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' tmp_addflag=' $pic_flag' ;; pgf77* | pgf90* | pgf95* | pgfortran*) # Portland Group f77 and f90 compilers whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' tmp_addflag=' $pic_flag -Mnomain' ;; ecc*,ia64* | icc*,ia64*) # Intel C compiler on ia64 tmp_addflag=' -i_dynamic' ;; efc*,ia64* | ifort*,ia64*) # Intel Fortran compiler on ia64 tmp_addflag=' -i_dynamic -nofor_main' ;; ifc* | ifort*) # Intel Fortran compiler tmp_addflag=' -nofor_main' ;; lf95*) # Lahey Fortran 8.1 whole_archive_flag_spec= tmp_sharedflag='--shared' ;; xl[cC]* | bgxl[cC]* | mpixl[cC]*) # IBM XL C 8.0 on PPC (deal with xlf below) tmp_sharedflag='-qmkshrobj' tmp_addflag= ;; nvcc*) # Cuda Compiler Driver 2.2 whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' compiler_needs_object=yes ;; esac case `$CC -V 2>&1 | sed 5q` in *Sun\ C*) # Sun C 5.9 whole_archive_flag_spec='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' compiler_needs_object=yes tmp_sharedflag='-G' ;; *Sun\ F*) # Sun Fortran 8.3 tmp_sharedflag='-G' ;; esac archive_cmds='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' if test "x$supports_anon_versioning" = xyes; then archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~ cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ echo "local: *; };" >> $output_objdir/$libname.ver~ $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib' fi case $cc_basename in xlf* | bgf* | bgxlf* | mpixlf*) # IBM XL Fortran 10.1 on PPC cannot create shared libs itself whole_archive_flag_spec='--whole-archive$convenience --no-whole-archive' hardcode_libdir_flag_spec= hardcode_libdir_flag_spec_ld='-rpath $libdir' archive_cmds='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib' if test "x$supports_anon_versioning" = xyes; then archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~ cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ echo "local: *; };" >> $output_objdir/$libname.ver~ $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib' fi ;; esac else ld_shlibs=no fi ;; netbsd*) if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then archive_cmds='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib' wlarc= else archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' fi ;; solaris*) if $LD -v 2>&1 | $GREP 'BFD 2\.8' > /dev/null; then ld_shlibs=no cat <<_LT_EOF 1>&2 *** Warning: The releases 2.8.* of the GNU linker cannot reliably *** create shared libraries on Solaris systems. Therefore, libtool *** is disabling shared libraries support. We urge you to upgrade GNU *** binutils to release 2.9.1 or newer. Another option is to modify *** your PATH or compiler configuration so that the native linker is *** used, and then restart. _LT_EOF elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' else ld_shlibs=no fi ;; sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*) case `$LD -v 2>&1` in *\ [01].* | *\ 2.[0-9].* | *\ 2.1[0-5].*) ld_shlibs=no cat <<_LT_EOF 1>&2 *** Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not *** reliably create shared libraries on SCO systems. Therefore, libtool *** is disabling shared libraries support. We urge you to upgrade GNU *** binutils to release 2.16.91.0.3 or newer. Another option is to modify *** your PATH or compiler configuration so that the native linker is *** used, and then restart. _LT_EOF ;; *) # For security reasons, it is highly recommended that you always # use absolute paths for naming shared libraries, and exclude the # DT_RUNPATH tag from executables and libraries. But doing so # requires that you compile everything twice, which is a pain. if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' else ld_shlibs=no fi ;; esac ;; sunos4*) archive_cmds='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags' wlarc= hardcode_direct=yes hardcode_shlibpath_var=no ;; *) if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' else ld_shlibs=no fi ;; esac if test "$ld_shlibs" = no; then runpath_var= hardcode_libdir_flag_spec= export_dynamic_flag_spec= whole_archive_flag_spec= fi else # PORTME fill in a description of your system's linker (not GNU ld) case $host_os in aix3*) allow_undefined_flag=unsupported always_export_symbols=yes archive_expsym_cmds='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname' # Note: this linker hardcodes the directories in LIBPATH if there # are no directories specified by -L. hardcode_minus_L=yes if test "$GCC" = yes && test -z "$lt_prog_compiler_static"; then # Neither direct hardcoding nor static linking is supported with a # broken collect2. hardcode_direct=unsupported fi ;; aix[4-9]*) if test "$host_cpu" = ia64; then # On IA64, the linker does run time linking by default, so we don't # have to do anything special. aix_use_runtimelinking=no exp_sym_flag='-Bexport' no_entry_flag="" else # If we're using GNU nm, then we don't want the "-C" option. # -C means demangle to AIX nm, but means don't demangle with GNU nm # Also, AIX nm treats weak defined symbols like other global # defined symbols, whereas GNU nm marks them as "W". if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then export_symbols_cmds='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' else export_symbols_cmds='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' fi aix_use_runtimelinking=no # Test if we are trying to use run time linking or normal # AIX style linking. If -brtl is somewhere in LDFLAGS, we # need to do runtime linking. case $host_os in aix4.[23]|aix4.[23].*|aix[5-9]*) for ld_flag in $LDFLAGS; do if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then aix_use_runtimelinking=yes break fi done ;; esac exp_sym_flag='-bexport' no_entry_flag='-bnoentry' fi # When large executables or shared objects are built, AIX ld can # have problems creating the table of contents. If linking a library # or program results in "error TOC overflow" add -mminimal-toc to # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS. archive_cmds='' hardcode_direct=yes hardcode_direct_absolute=yes hardcode_libdir_separator=':' link_all_deplibs=yes file_list_spec='${wl}-f,' if test "$GCC" = yes; then case $host_os in aix4.[012]|aix4.[012].*) # We only want to do this on AIX 4.2 and lower, the check # below for broken collect2 doesn't work under 4.3+ collect2name=`${CC} -print-prog-name=collect2` if test -f "$collect2name" && strings "$collect2name" | $GREP resolve_lib_name >/dev/null then # We have reworked collect2 : else # We have old collect2 hardcode_direct=unsupported # It fails to find uninstalled libraries when the uninstalled # path is not listed in the libpath. Setting hardcode_minus_L # to unsupported forces relinking hardcode_minus_L=yes hardcode_libdir_flag_spec='-L$libdir' hardcode_libdir_separator= fi ;; esac shared_flag='-shared' if test "$aix_use_runtimelinking" = yes; then shared_flag="$shared_flag "'${wl}-G' fi else # not using gcc if test "$host_cpu" = ia64; then # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release # chokes on -Wl,-G. The following line is correct: shared_flag='-G' else if test "$aix_use_runtimelinking" = yes; then shared_flag='${wl}-G' else shared_flag='${wl}-bM:SRE' fi fi fi export_dynamic_flag_spec='${wl}-bexpall' # It seems that -bexpall does not export symbols beginning with # underscore (_), so it is better to generate a list of symbols to export. always_export_symbols=yes if test "$aix_use_runtimelinking" = yes; then # Warning - without using the other runtime loading flags (-brtl), # -berok will link without error, but may produce a broken library. allow_undefined_flag='-berok' # Determine the default libpath from the value encoded in an # empty executable. if test "${lt_cv_aix_libpath+set}" = set; then aix_libpath=$lt_cv_aix_libpath else if ${lt_cv_aix_libpath_+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : lt_aix_libpath_sed=' /Import File Strings/,/^$/ { /^0/ { s/^0 *\([^ ]*\) *$/\1/ p } }' lt_cv_aix_libpath_=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` # Check for a 64-bit object if we didn't find anything. if test -z "$lt_cv_aix_libpath_"; then lt_cv_aix_libpath_=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` fi fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext if test -z "$lt_cv_aix_libpath_"; then lt_cv_aix_libpath_="/usr/lib:/lib" fi fi aix_libpath=$lt_cv_aix_libpath_ fi hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath" archive_expsym_cmds='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag" else if test "$host_cpu" = ia64; then hardcode_libdir_flag_spec='${wl}-R $libdir:/usr/lib:/lib' allow_undefined_flag="-z nodefs" archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols" else # Determine the default libpath from the value encoded in an # empty executable. if test "${lt_cv_aix_libpath+set}" = set; then aix_libpath=$lt_cv_aix_libpath else if ${lt_cv_aix_libpath_+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : lt_aix_libpath_sed=' /Import File Strings/,/^$/ { /^0/ { s/^0 *\([^ ]*\) *$/\1/ p } }' lt_cv_aix_libpath_=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` # Check for a 64-bit object if we didn't find anything. if test -z "$lt_cv_aix_libpath_"; then lt_cv_aix_libpath_=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` fi fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext if test -z "$lt_cv_aix_libpath_"; then lt_cv_aix_libpath_="/usr/lib:/lib" fi fi aix_libpath=$lt_cv_aix_libpath_ fi hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath" # Warning - without using the other run time loading flags, # -berok will link without error, but may produce a broken library. no_undefined_flag=' ${wl}-bernotok' allow_undefined_flag=' ${wl}-berok' if test "$with_gnu_ld" = yes; then # We only use this code for GNU lds that support --whole-archive. whole_archive_flag_spec='${wl}--whole-archive$convenience ${wl}--no-whole-archive' else # Exported symbols can be pulled into shared objects from archives whole_archive_flag_spec='$convenience' fi archive_cmds_need_lc=yes # This is similar to how AIX traditionally builds its shared libraries. archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname' fi fi ;; amigaos*) case $host_cpu in powerpc) # see comment about AmigaOS4 .so support archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' archive_expsym_cmds='' ;; m68k) archive_cmds='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' hardcode_libdir_flag_spec='-L$libdir' hardcode_minus_L=yes ;; esac ;; bsdi[45]*) export_dynamic_flag_spec=-rdynamic ;; cygwin* | mingw* | pw32* | cegcc*) # When not using gcc, we currently assume that we are using # Microsoft Visual C++. # hardcode_libdir_flag_spec is actually meaningless, as there is # no search path for DLLs. case $cc_basename in cl*) # Native MSVC hardcode_libdir_flag_spec=' ' allow_undefined_flag=unsupported always_export_symbols=yes file_list_spec='@' # Tell ltmain to make .lib files, not .a files. libext=lib # Tell ltmain to make .dll files, not .so files. shrext_cmds=".dll" # FIXME: Setting linknames here is a bad hack. archive_cmds='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames=' archive_expsym_cmds='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then sed -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp; else sed -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp; fi~ $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~ linknames=' # The linker will not automatically build a static lib if we build a DLL. # _LT_TAGVAR(old_archive_from_new_cmds, )='true' enable_shared_with_static_runtimes=yes export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1,DATA/'\'' | $SED -e '\''/^[AITW][ ]/s/.*[ ]//'\'' | sort | uniq > $export_symbols' # Don't use ranlib old_postinstall_cmds='chmod 644 $oldlib' postlink_cmds='lt_outputfile="@OUTPUT@"~ lt_tool_outputfile="@TOOL_OUTPUT@"~ case $lt_outputfile in *.exe|*.EXE) ;; *) lt_outputfile="$lt_outputfile.exe" lt_tool_outputfile="$lt_tool_outputfile.exe" ;; esac~ if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1; $RM "$lt_outputfile.manifest"; fi' ;; *) # Assume MSVC wrapper hardcode_libdir_flag_spec=' ' allow_undefined_flag=unsupported # Tell ltmain to make .lib files, not .a files. libext=lib # Tell ltmain to make .dll files, not .so files. shrext_cmds=".dll" # FIXME: Setting linknames here is a bad hack. archive_cmds='$CC -o $lib $libobjs $compiler_flags `func_echo_all "$deplibs" | $SED '\''s/ -lc$//'\''` -link -dll~linknames=' # The linker will automatically build a .lib file if we build a DLL. old_archive_from_new_cmds='true' # FIXME: Should let the user specify the lib program. old_archive_cmds='lib -OUT:$oldlib$oldobjs$old_deplibs' enable_shared_with_static_runtimes=yes ;; esac ;; darwin* | rhapsody*) archive_cmds_need_lc=no hardcode_direct=no hardcode_automatic=yes hardcode_shlibpath_var=unsupported if test "$lt_cv_ld_force_load" = "yes"; then whole_archive_flag_spec='`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience ${wl}-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`' else whole_archive_flag_spec='' fi link_all_deplibs=yes allow_undefined_flag="$_lt_dar_allow_undefined" case $cc_basename in ifort*) _lt_dar_can_shared=yes ;; *) _lt_dar_can_shared=$GCC ;; esac if test "$_lt_dar_can_shared" = "yes"; then output_verbose_link_cmd=func_echo_all archive_cmds="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod${_lt_dsymutil}" module_cmds="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dsymutil}" archive_expsym_cmds="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring ${_lt_dar_single_mod}${_lt_dar_export_syms}${_lt_dsymutil}" module_expsym_cmds="sed -e 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dar_export_syms}${_lt_dsymutil}" else ld_shlibs=no fi ;; dgux*) archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' hardcode_libdir_flag_spec='-L$libdir' hardcode_shlibpath_var=no ;; freebsd1*) ld_shlibs=no ;; # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor # support. Future versions do this automatically, but an explicit c++rt0.o # does not break anything, and helps significantly (at the cost of a little # extra space). freebsd2.2*) archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o' hardcode_libdir_flag_spec='-R$libdir' hardcode_direct=yes hardcode_shlibpath_var=no ;; # Unfortunately, older versions of FreeBSD 2 do not have this feature. freebsd2*) archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' hardcode_direct=yes hardcode_minus_L=yes hardcode_shlibpath_var=no ;; # FreeBSD 3 and greater uses gcc -shared to do shared libraries. freebsd* | dragonfly*) archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' hardcode_libdir_flag_spec='-R$libdir' hardcode_direct=yes hardcode_shlibpath_var=no ;; hpux9*) if test "$GCC" = yes; then archive_cmds='$RM $output_objdir/$soname~$CC -shared $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' else archive_cmds='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' fi hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir' hardcode_libdir_separator=: hardcode_direct=yes # hardcode_minus_L: Not really in the search PATH, # but as the default location of the library. hardcode_minus_L=yes export_dynamic_flag_spec='${wl}-E' ;; hpux10*) if test "$GCC" = yes && test "$with_gnu_ld" = no; then archive_cmds='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' else archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags' fi if test "$with_gnu_ld" = no; then hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir' hardcode_libdir_flag_spec_ld='+b $libdir' hardcode_libdir_separator=: hardcode_direct=yes hardcode_direct_absolute=yes export_dynamic_flag_spec='${wl}-E' # hardcode_minus_L: Not really in the search PATH, # but as the default location of the library. hardcode_minus_L=yes fi ;; hpux11*) if test "$GCC" = yes && test "$with_gnu_ld" = no; then case $host_cpu in hppa*64*) archive_cmds='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' ;; ia64*) archive_cmds='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags' ;; *) archive_cmds='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' ;; esac else case $host_cpu in hppa*64*) archive_cmds='$CC -b ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' ;; ia64*) archive_cmds='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags' ;; *) # Older versions of the 11.00 compiler do not understand -b yet # (HP92453-01 A.11.01.20 doesn't, HP92453-01 B.11.X.35175-35176.GP does) { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC understands -b" >&5 $as_echo_n "checking if $CC understands -b... " >&6; } if ${lt_cv_prog_compiler__b+:} false; then : $as_echo_n "(cached) " >&6 else lt_cv_prog_compiler__b=no save_LDFLAGS="$LDFLAGS" LDFLAGS="$LDFLAGS -b" echo "$lt_simple_link_test_code" > conftest.$ac_ext if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then # The linker can only warn and ignore the option if not recognized # So say no if there are warnings if test -s conftest.err; then # Append any errors to the config.log. cat conftest.err 1>&5 $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 if diff conftest.exp conftest.er2 >/dev/null; then lt_cv_prog_compiler__b=yes fi else lt_cv_prog_compiler__b=yes fi fi $RM -r conftest* LDFLAGS="$save_LDFLAGS" fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler__b" >&5 $as_echo "$lt_cv_prog_compiler__b" >&6; } if test x"$lt_cv_prog_compiler__b" = xyes; then archive_cmds='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' else archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags' fi ;; esac fi if test "$with_gnu_ld" = no; then hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir' hardcode_libdir_separator=: case $host_cpu in hppa*64*|ia64*) hardcode_direct=no hardcode_shlibpath_var=no ;; *) hardcode_direct=yes hardcode_direct_absolute=yes export_dynamic_flag_spec='${wl}-E' # hardcode_minus_L: Not really in the search PATH, # but as the default location of the library. hardcode_minus_L=yes ;; esac fi ;; irix5* | irix6* | nonstopux*) if test "$GCC" = yes; then archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' # Try to use the -exported_symbol ld option, if it does not # work, assume that -exports_file does not work either and # implicitly export all symbols. # This should be the same for all languages, so no per-tag cache variable. { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $host_os linker accepts -exported_symbol" >&5 $as_echo_n "checking whether the $host_os linker accepts -exported_symbol... " >&6; } if ${lt_cv_irix_exported_symbol+:} false; then : $as_echo_n "(cached) " >&6 else save_LDFLAGS="$LDFLAGS" LDFLAGS="$LDFLAGS -shared ${wl}-exported_symbol ${wl}foo ${wl}-update_registry ${wl}/dev/null" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int foo (void) { return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : lt_cv_irix_exported_symbol=yes else lt_cv_irix_exported_symbol=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LDFLAGS="$save_LDFLAGS" fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_irix_exported_symbol" >&5 $as_echo "$lt_cv_irix_exported_symbol" >&6; } if test "$lt_cv_irix_exported_symbol" = yes; then archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations ${wl}-exports_file ${wl}$export_symbols -o $lib' fi else archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -exports_file $export_symbols -o $lib' fi archive_cmds_need_lc='no' hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' hardcode_libdir_separator=: inherit_rpath=yes link_all_deplibs=yes ;; netbsd*) if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' # a.out else archive_cmds='$LD -shared -o $lib $libobjs $deplibs $linker_flags' # ELF fi hardcode_libdir_flag_spec='-R$libdir' hardcode_direct=yes hardcode_shlibpath_var=no ;; newsos6) archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' hardcode_direct=yes hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' hardcode_libdir_separator=: hardcode_shlibpath_var=no ;; *nto* | *qnx*) ;; openbsd*) if test -f /usr/libexec/ld.so; then hardcode_direct=yes hardcode_shlibpath_var=no hardcode_direct_absolute=yes if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' archive_expsym_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-retain-symbols-file,$export_symbols' hardcode_libdir_flag_spec='${wl}-rpath,$libdir' export_dynamic_flag_spec='${wl}-E' else case $host_os in openbsd[01].* | openbsd2.[0-7] | openbsd2.[0-7].*) archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' hardcode_libdir_flag_spec='-R$libdir' ;; *) archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' hardcode_libdir_flag_spec='${wl}-rpath,$libdir' ;; esac fi else ld_shlibs=no fi ;; os2*) hardcode_libdir_flag_spec='-L$libdir' hardcode_minus_L=yes allow_undefined_flag=unsupported archive_cmds='$ECHO "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~echo DATA >> $output_objdir/$libname.def~echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def' old_archive_from_new_cmds='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def' ;; osf3*) if test "$GCC" = yes; then allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*' archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' else allow_undefined_flag=' -expect_unresolved \*' archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' fi archive_cmds_need_lc='no' hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' hardcode_libdir_separator=: ;; osf4* | osf5*) # as osf3* with the addition of -msym flag if test "$GCC" = yes; then allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*' archive_cmds='$CC -shared${allow_undefined_flag} $pic_flag $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' else allow_undefined_flag=' -expect_unresolved \*' archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' archive_expsym_cmds='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; printf "%s\\n" "-hidden">> $lib.exp~ $CC -shared${allow_undefined_flag} ${wl}-input ${wl}$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~$RM $lib.exp' # Both c and cxx compiler support -rpath directly hardcode_libdir_flag_spec='-rpath $libdir' fi archive_cmds_need_lc='no' hardcode_libdir_separator=: ;; solaris*) no_undefined_flag=' -z defs' if test "$GCC" = yes; then wlarc='${wl}' archive_cmds='$CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ $CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp' else case `$CC -V 2>&1` in *"Compilers 5.0"*) wlarc='' archive_cmds='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags' archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp' ;; *) wlarc='${wl}' archive_cmds='$CC -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $compiler_flags' archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ $CC -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp' ;; esac fi hardcode_libdir_flag_spec='-R$libdir' hardcode_shlibpath_var=no case $host_os in solaris2.[0-5] | solaris2.[0-5].*) ;; *) # The compiler driver will combine and reorder linker options, # but understands `-z linker_flag'. GCC discards it without `$wl', # but is careful enough not to reorder. # Supported since Solaris 2.6 (maybe 2.5.1?) if test "$GCC" = yes; then whole_archive_flag_spec='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract' else whole_archive_flag_spec='-z allextract$convenience -z defaultextract' fi ;; esac link_all_deplibs=yes ;; sunos4*) if test "x$host_vendor" = xsequent; then # Use $CC to link under sequent, because it throws in some extra .o # files that make .init and .fini sections work. archive_cmds='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags' else archive_cmds='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags' fi hardcode_libdir_flag_spec='-L$libdir' hardcode_direct=yes hardcode_minus_L=yes hardcode_shlibpath_var=no ;; sysv4) case $host_vendor in sni) archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' hardcode_direct=yes # is this really true??? ;; siemens) ## LD is ld it makes a PLAMLIB ## CC just makes a GrossModule. archive_cmds='$LD -G -o $lib $libobjs $deplibs $linker_flags' reload_cmds='$CC -r -o $output$reload_objs' hardcode_direct=no ;; motorola) archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' hardcode_direct=no #Motorola manual says yes, but my tests say they lie ;; esac runpath_var='LD_RUN_PATH' hardcode_shlibpath_var=no ;; sysv4.3*) archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' hardcode_shlibpath_var=no export_dynamic_flag_spec='-Bexport' ;; sysv4*MP*) if test -d /usr/nec; then archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' hardcode_shlibpath_var=no runpath_var=LD_RUN_PATH hardcode_runpath_var=yes ld_shlibs=yes fi ;; sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7* | sco3.2v5.0.[024]*) no_undefined_flag='${wl}-z,text' archive_cmds_need_lc=no hardcode_shlibpath_var=no runpath_var='LD_RUN_PATH' if test "$GCC" = yes; then archive_cmds='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' archive_expsym_cmds='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' else archive_cmds='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' archive_expsym_cmds='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' fi ;; sysv5* | sco3.2v5* | sco5v6*) # Note: We can NOT use -z defs as we might desire, because we do not # link with -lc, and that would cause any symbols used from libc to # always be unresolved, which means just about no library would # ever link correctly. If we're not using GNU ld we use -z text # though, which does catch some bad symbols but isn't as heavy-handed # as -z defs. no_undefined_flag='${wl}-z,text' allow_undefined_flag='${wl}-z,nodefs' archive_cmds_need_lc=no hardcode_shlibpath_var=no hardcode_libdir_flag_spec='${wl}-R,$libdir' hardcode_libdir_separator=':' link_all_deplibs=yes export_dynamic_flag_spec='${wl}-Bexport' runpath_var='LD_RUN_PATH' if test "$GCC" = yes; then archive_cmds='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' archive_expsym_cmds='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' else archive_cmds='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' archive_expsym_cmds='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' fi ;; uts4*) archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' hardcode_libdir_flag_spec='-L$libdir' hardcode_shlibpath_var=no ;; *) ld_shlibs=no ;; esac if test x$host_vendor = xsni; then case $host in sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) export_dynamic_flag_spec='${wl}-Blargedynsym' ;; esac fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs" >&5 $as_echo "$ld_shlibs" >&6; } test "$ld_shlibs" = no && can_build_shared=no with_gnu_ld=$with_gnu_ld # # Do we need to explicitly link libc? # case "x$archive_cmds_need_lc" in x|xyes) # Assume -lc should be added archive_cmds_need_lc=yes if test "$enable_shared" = yes && test "$GCC" = yes; then case $archive_cmds in *'~'*) # FIXME: we may have to deal with multi-command sequences. ;; '$CC '*) # Test whether the compiler implicitly links with -lc since on some # systems, -lgcc has to come before -lc. If gcc already passes -lc # to ld, don't add -lc before -lgcc. { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5 $as_echo_n "checking whether -lc should be explicitly linked in... " >&6; } if ${lt_cv_archive_cmds_need_lc+:} false; then : $as_echo_n "(cached) " >&6 else $RM conftest* echo "$lt_simple_compile_test_code" > conftest.$ac_ext if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 (eval $ac_compile) 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } 2>conftest.err; then soname=conftest lib=conftest libobjs=conftest.$ac_objext deplibs= wl=$lt_prog_compiler_wl pic_flag=$lt_prog_compiler_pic compiler_flags=-v linker_flags=-v verstring= output_objdir=. libname=conftest lt_save_allow_undefined_flag=$allow_undefined_flag allow_undefined_flag= if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1\""; } >&5 (eval $archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } then lt_cv_archive_cmds_need_lc=no else lt_cv_archive_cmds_need_lc=yes fi allow_undefined_flag=$lt_save_allow_undefined_flag else cat conftest.err 1>&5 fi $RM conftest* fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc" >&5 $as_echo "$lt_cv_archive_cmds_need_lc" >&6; } archive_cmds_need_lc=$lt_cv_archive_cmds_need_lc ;; esac fi ;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5 $as_echo_n "checking dynamic linker characteristics... " >&6; } if test "$GCC" = yes; then case $host_os in darwin*) lt_awk_arg="/^libraries:/,/LR/" ;; *) lt_awk_arg="/^libraries:/" ;; esac case $host_os in mingw* | cegcc*) lt_sed_strip_eq="s,=\([A-Za-z]:\),\1,g" ;; *) lt_sed_strip_eq="s,=/,/,g" ;; esac lt_search_path_spec=`$CC -print-search-dirs | awk $lt_awk_arg | $SED -e "s/^libraries://" -e $lt_sed_strip_eq` case $lt_search_path_spec in *\;*) # if the path contains ";" then we assume it to be the separator # otherwise default to the standard path separator (i.e. ":") - it is # assumed that no part of a normal pathname contains ";" but that should # okay in the real world where ";" in dirpaths is itself problematic. lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED 's/;/ /g'` ;; *) lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED "s/$PATH_SEPARATOR/ /g"` ;; esac # Ok, now we have the path, separated by spaces, we can step through it # and add multilib dir if necessary. lt_tmp_lt_search_path_spec= lt_multi_os_dir=`$CC $CPPFLAGS $CFLAGS $LDFLAGS -print-multi-os-directory 2>/dev/null` for lt_sys_path in $lt_search_path_spec; do if test -d "$lt_sys_path/$lt_multi_os_dir"; then lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path/$lt_multi_os_dir" else test -d "$lt_sys_path" && \ lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path" fi done lt_search_path_spec=`$ECHO "$lt_tmp_lt_search_path_spec" | awk ' BEGIN {RS=" "; FS="/|\n";} { lt_foo=""; lt_count=0; for (lt_i = NF; lt_i > 0; lt_i--) { if ($lt_i != "" && $lt_i != ".") { if ($lt_i == "..") { lt_count++; } else { if (lt_count == 0) { lt_foo="/" $lt_i lt_foo; } else { lt_count--; } } } } if (lt_foo != "") { lt_freq[lt_foo]++; } if (lt_freq[lt_foo] == 1) { print lt_foo; } }'` # AWK program above erroneously prepends '/' to C:/dos/paths # for these hosts. case $host_os in mingw* | cegcc*) lt_search_path_spec=`$ECHO "$lt_search_path_spec" |\ $SED 's,/\([A-Za-z]:\),\1,g'` ;; esac sys_lib_search_path_spec=`$ECHO "$lt_search_path_spec" | $lt_NL2SP` else sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib" fi library_names_spec= libname_spec='lib$name' soname_spec= shrext_cmds=".so" postinstall_cmds= postuninstall_cmds= finish_cmds= finish_eval= shlibpath_var= shlibpath_overrides_runpath=unknown version_type=none dynamic_linker="$host_os ld.so" sys_lib_dlsearch_path_spec="/lib /usr/lib" need_lib_prefix=unknown hardcode_into_libs=no # when you set need_version to no, make sure it does not cause -set_version # flags to be left without arguments need_version=unknown case $host_os in aix3*) version_type=linux library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a' shlibpath_var=LIBPATH # AIX 3 has no versioning support, so we append a major version to the name. soname_spec='${libname}${release}${shared_ext}$major' ;; aix[4-9]*) version_type=linux need_lib_prefix=no need_version=no hardcode_into_libs=yes if test "$host_cpu" = ia64; then # AIX 5 supports IA64 library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}' shlibpath_var=LD_LIBRARY_PATH else # With GCC up to 2.95.x, collect2 would create an import file # for dependence libraries. The import file would start with # the line `#! .'. This would cause the generated library to # depend on `.', always an invalid library. This was fixed in # development snapshots of GCC prior to 3.0. case $host_os in aix4 | aix4.[01] | aix4.[01].*) if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)' echo ' yes ' echo '#endif'; } | ${CC} -E - | $GREP yes > /dev/null; then : else can_build_shared=no fi ;; esac # AIX (on Power*) has no versioning support, so currently we can not hardcode correct # soname into executable. Probably we can add versioning support to # collect2, so additional links can be useful in future. if test "$aix_use_runtimelinking" = yes; then # If using run time linking (on AIX 4.2 or later) use lib.so # instead of lib.a to let people know that these are not # typical AIX shared libraries. library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' else # We preserve .a as extension for shared libraries through AIX4.2 # and later when we are not doing run time linking. library_names_spec='${libname}${release}.a $libname.a' soname_spec='${libname}${release}${shared_ext}$major' fi shlibpath_var=LIBPATH fi ;; amigaos*) case $host_cpu in powerpc) # Since July 2007 AmigaOS4 officially supports .so libraries. # When compiling the executable, add -use-dynld -Lsobjs: to the compileline. library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' ;; m68k) library_names_spec='$libname.ixlibrary $libname.a' # Create ${libname}_ixlibrary.a entries in /sys/libs. finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done' ;; esac ;; beos*) library_names_spec='${libname}${shared_ext}' dynamic_linker="$host_os ld.so" shlibpath_var=LIBRARY_PATH ;; bsdi[45]*) version_type=linux need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir' shlibpath_var=LD_LIBRARY_PATH sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib" sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib" # the default ld.so.conf also contains /usr/contrib/lib and # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow # libtool to hard-code these into programs ;; cygwin* | mingw* | pw32* | cegcc*) version_type=windows shrext_cmds=".dll" need_version=no need_lib_prefix=no case $GCC,$cc_basename in yes,*) # gcc library_names_spec='$libname.dll.a' # DLL is installed to $(libdir)/../bin by postinstall_cmds postinstall_cmds='base_file=`basename \${file}`~ dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~ dldir=$destdir/`dirname \$dlpath`~ test -d \$dldir || mkdir -p \$dldir~ $install_prog $dir/$dlname \$dldir/$dlname~ chmod a+x \$dldir/$dlname~ if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then eval '\''$striplib \$dldir/$dlname'\'' || exit \$?; fi' postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ dlpath=$dir/\$dldll~ $RM \$dlpath' shlibpath_overrides_runpath=yes case $host_os in cygwin*) # Cygwin DLLs use 'cyg' prefix rather than 'lib' soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/lib/w32api" ;; mingw* | cegcc*) # MinGW DLLs use traditional 'lib' prefix soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' ;; pw32*) # pw32 DLLs use 'pw' prefix rather than 'lib' library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' ;; esac dynamic_linker='Win32 ld.exe' ;; *,cl*) # Native MSVC libname_spec='$name' soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' library_names_spec='${libname}.dll.lib' case $build_os in mingw*) sys_lib_search_path_spec= lt_save_ifs=$IFS IFS=';' for lt_path in $LIB do IFS=$lt_save_ifs # Let DOS variable expansion print the short 8.3 style file name. lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"` sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path" done IFS=$lt_save_ifs # Convert to MSYS style. sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([a-zA-Z]\\):| /\\1|g' -e 's|^ ||'` ;; cygwin*) # Convert to unix form, then to dos form, then back to unix form # but this time dos style (no spaces!) so that the unix form looks # like /cygdrive/c/PROGRA~1:/cygdr... sys_lib_search_path_spec=`cygpath --path --unix "$LIB"` sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null` sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` ;; *) sys_lib_search_path_spec="$LIB" if $ECHO "$sys_lib_search_path_spec" | $GREP ';[c-zC-Z]:/' >/dev/null; then # It is most probably a Windows format PATH. sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` else sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` fi # FIXME: find the short name or the path components, as spaces are # common. (e.g. "Program Files" -> "PROGRA~1") ;; esac # DLL is installed to $(libdir)/../bin by postinstall_cmds postinstall_cmds='base_file=`basename \${file}`~ dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~ dldir=$destdir/`dirname \$dlpath`~ test -d \$dldir || mkdir -p \$dldir~ $install_prog $dir/$dlname \$dldir/$dlname' postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ dlpath=$dir/\$dldll~ $RM \$dlpath' shlibpath_overrides_runpath=yes dynamic_linker='Win32 link.exe' ;; *) # Assume MSVC wrapper library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib' dynamic_linker='Win32 ld.exe' ;; esac # FIXME: first we should search . and the directory the executable is in shlibpath_var=PATH ;; darwin* | rhapsody*) dynamic_linker="$host_os dyld" version_type=darwin need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${major}$shared_ext ${libname}$shared_ext' soname_spec='${libname}${release}${major}$shared_ext' shlibpath_overrides_runpath=yes shlibpath_var=DYLD_LIBRARY_PATH shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`' sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/local/lib" sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib' ;; dgux*) version_type=linux need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LD_LIBRARY_PATH ;; freebsd1*) dynamic_linker=no ;; freebsd* | dragonfly*) # DragonFly does not have aout. When/if they implement a new # versioning mechanism, adjust this. if test -x /usr/bin/objformat; then objformat=`/usr/bin/objformat` else case $host_os in freebsd[123]*) objformat=aout ;; *) objformat=elf ;; esac fi version_type=freebsd-$objformat case $version_type in freebsd-elf*) library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' need_version=no need_lib_prefix=no ;; freebsd-*) library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix' need_version=yes ;; esac shlibpath_var=LD_LIBRARY_PATH case $host_os in freebsd2*) shlibpath_overrides_runpath=yes ;; freebsd3.[01]* | freebsdelf3.[01]*) shlibpath_overrides_runpath=yes hardcode_into_libs=yes ;; freebsd3.[2-9]* | freebsdelf3.[2-9]* | \ freebsd4.[0-5] | freebsdelf4.[0-5] | freebsd4.1.1 | freebsdelf4.1.1) shlibpath_overrides_runpath=no hardcode_into_libs=yes ;; *) # from 4.6 on, and DragonFly shlibpath_overrides_runpath=yes hardcode_into_libs=yes ;; esac ;; gnu*) version_type=linux need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LD_LIBRARY_PATH hardcode_into_libs=yes ;; haiku*) version_type=linux need_lib_prefix=no need_version=no dynamic_linker="$host_os runtime_loader" library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LIBRARY_PATH shlibpath_overrides_runpath=yes sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib' hardcode_into_libs=yes ;; hpux9* | hpux10* | hpux11*) # Give a soname corresponding to the major version so that dld.sl refuses to # link against other versions. version_type=sunos need_lib_prefix=no need_version=no case $host_cpu in ia64*) shrext_cmds='.so' hardcode_into_libs=yes dynamic_linker="$host_os dld.so" shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' if test "X$HPUX_IA64_MODE" = X32; then sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" else sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" fi sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec ;; hppa*64*) shrext_cmds='.sl' hardcode_into_libs=yes dynamic_linker="$host_os dld.sl" shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64" sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec ;; *) shrext_cmds='.sl' dynamic_linker="$host_os dld.sl" shlibpath_var=SHLIB_PATH shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' ;; esac # HP-UX runs *really* slowly unless shared libraries are mode 555, ... postinstall_cmds='chmod 555 $lib' # or fails outright, so override atomically: install_override_mode=555 ;; interix[3-9]*) version_type=linux need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=no hardcode_into_libs=yes ;; irix5* | irix6* | nonstopux*) case $host_os in nonstopux*) version_type=nonstopux ;; *) if test "$lt_cv_prog_gnu_ld" = yes; then version_type=linux else version_type=irix fi ;; esac need_lib_prefix=no need_version=no soname_spec='${libname}${release}${shared_ext}$major' library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}' case $host_os in irix5* | nonstopux*) libsuff= shlibsuff= ;; *) case $LD in # libtool.m4 will add one of these switches to LD *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ") libsuff= shlibsuff= libmagic=32-bit;; *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ") libsuff=32 shlibsuff=N32 libmagic=N32;; *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ") libsuff=64 shlibsuff=64 libmagic=64-bit;; *) libsuff= shlibsuff= libmagic=never-match;; esac ;; esac shlibpath_var=LD_LIBRARY${shlibsuff}_PATH shlibpath_overrides_runpath=no sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}" sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}" hardcode_into_libs=yes ;; # No shared lib support for Linux oldld, aout, or coff. linux*oldld* | linux*aout* | linux*coff*) dynamic_linker=no ;; # This must be Linux ELF. linux* | k*bsd*-gnu | kopensolaris*-gnu) version_type=linux need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=no # Some binutils ld are patched to set DT_RUNPATH if ${lt_cv_shlibpath_overrides_runpath+:} false; then : $as_echo_n "(cached) " >&6 else lt_cv_shlibpath_overrides_runpath=no save_LDFLAGS=$LDFLAGS save_libdir=$libdir eval "libdir=/foo; wl=\"$lt_prog_compiler_wl\"; \ LDFLAGS=\"\$LDFLAGS $hardcode_libdir_flag_spec\"" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : if ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null; then : lt_cv_shlibpath_overrides_runpath=yes fi fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LDFLAGS=$save_LDFLAGS libdir=$save_libdir fi shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath # This implies no fast_install, which is unacceptable. # Some rework will be needed to allow for fast_install # before this can be enabled. hardcode_into_libs=yes # Add ABI-specific directories to the system library path. sys_lib_dlsearch_path_spec="/lib64 /usr/lib64 /lib /usr/lib" # Append ld.so.conf contents to the search path if test -f /etc/ld.so.conf; then lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[ ]*hwcap[ ]/d;s/[:, ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '` sys_lib_dlsearch_path_spec="$sys_lib_dlsearch_path_spec $lt_ld_extra" fi # We used to test for /lib/ld.so.1 and disable shared libraries on # powerpc, because MkLinux only supported shared libraries with the # GNU dynamic linker. Since this was broken with cross compilers, # most powerpc-linux boxes support dynamic linking these days and # people can always --disable-shared, the test was removed, and we # assume the GNU/Linux dynamic linker is in use. dynamic_linker='GNU/Linux ld.so' ;; netbsd*) version_type=sunos need_lib_prefix=no need_version=no if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' dynamic_linker='NetBSD (a.out) ld.so' else library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' dynamic_linker='NetBSD ld.elf_so' fi shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes hardcode_into_libs=yes ;; newsos6) version_type=linux library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes ;; *nto* | *qnx*) version_type=qnx need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=no hardcode_into_libs=yes dynamic_linker='ldqnx.so' ;; openbsd*) version_type=sunos sys_lib_dlsearch_path_spec="/usr/lib" need_lib_prefix=no # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs. case $host_os in openbsd3.3 | openbsd3.3.*) need_version=yes ;; *) need_version=no ;; esac library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' shlibpath_var=LD_LIBRARY_PATH if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then case $host_os in openbsd2.[89] | openbsd2.[89].*) shlibpath_overrides_runpath=no ;; *) shlibpath_overrides_runpath=yes ;; esac else shlibpath_overrides_runpath=yes fi ;; os2*) libname_spec='$name' shrext_cmds=".dll" need_lib_prefix=no library_names_spec='$libname${shared_ext} $libname.a' dynamic_linker='OS/2 ld.exe' shlibpath_var=LIBPATH ;; osf3* | osf4* | osf5*) version_type=osf need_lib_prefix=no need_version=no soname_spec='${libname}${release}${shared_ext}$major' library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' shlibpath_var=LD_LIBRARY_PATH sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib" sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec" ;; rdos*) dynamic_linker=no ;; solaris*) version_type=linux need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes hardcode_into_libs=yes # ldd complains unless libraries are executable postinstall_cmds='chmod +x $lib' ;; sunos4*) version_type=sunos library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes if test "$with_gnu_ld" = yes; then need_lib_prefix=no fi need_version=yes ;; sysv4 | sysv4.3*) version_type=linux library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LD_LIBRARY_PATH case $host_vendor in sni) shlibpath_overrides_runpath=no need_lib_prefix=no runpath_var=LD_RUN_PATH ;; siemens) need_lib_prefix=no ;; motorola) need_lib_prefix=no need_version=no shlibpath_overrides_runpath=no sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib' ;; esac ;; sysv4*MP*) if test -d /usr/nec ;then version_type=linux library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}' soname_spec='$libname${shared_ext}.$major' shlibpath_var=LD_LIBRARY_PATH fi ;; sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*) version_type=freebsd-elf need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes hardcode_into_libs=yes if test "$with_gnu_ld" = yes; then sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib' else sys_lib_search_path_spec='/usr/ccs/lib /usr/lib' case $host_os in sco3.2v5*) sys_lib_search_path_spec="$sys_lib_search_path_spec /lib" ;; esac fi sys_lib_dlsearch_path_spec='/usr/lib' ;; tpf*) # TPF is a cross-target only. Preferred cross-host = GNU/Linux. version_type=linux need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=no hardcode_into_libs=yes ;; uts4*) version_type=linux library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LD_LIBRARY_PATH ;; *) dynamic_linker=no ;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5 $as_echo "$dynamic_linker" >&6; } test "$dynamic_linker" = no && can_build_shared=no variables_saved_for_relink="PATH $shlibpath_var $runpath_var" if test "$GCC" = yes; then variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" fi if test "${lt_cv_sys_lib_search_path_spec+set}" = set; then sys_lib_search_path_spec="$lt_cv_sys_lib_search_path_spec" fi if test "${lt_cv_sys_lib_dlsearch_path_spec+set}" = set; then sys_lib_dlsearch_path_spec="$lt_cv_sys_lib_dlsearch_path_spec" fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5 $as_echo_n "checking how to hardcode library paths into programs... " >&6; } hardcode_action= if test -n "$hardcode_libdir_flag_spec" || test -n "$runpath_var" || test "X$hardcode_automatic" = "Xyes" ; then # We can hardcode non-existent directories. if test "$hardcode_direct" != no && # If the only mechanism to avoid hardcoding is shlibpath_var, we # have to relink, otherwise we might link with an installed library # when we should be linking with a yet-to-be-installed one ## test "$_LT_TAGVAR(hardcode_shlibpath_var, )" != no && test "$hardcode_minus_L" != no; then # Linking always hardcodes the temporary library directory. hardcode_action=relink else # We can link without hardcoding, and we can hardcode nonexisting dirs. hardcode_action=immediate fi else # We cannot hardcode anything, or else we can only hardcode existing # directories. hardcode_action=unsupported fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hardcode_action" >&5 $as_echo "$hardcode_action" >&6; } if test "$hardcode_action" = relink || test "$inherit_rpath" = yes; then # Fast installation is not supported enable_fast_install=no elif test "$shlibpath_overrides_runpath" = yes || test "$enable_shared" = no; then # Fast installation is not necessary enable_fast_install=needless fi if test "x$enable_dlopen" != xyes; then enable_dlopen=unknown enable_dlopen_self=unknown enable_dlopen_self_static=unknown else lt_cv_dlopen=no lt_cv_dlopen_libs= case $host_os in beos*) lt_cv_dlopen="load_add_on" lt_cv_dlopen_libs= lt_cv_dlopen_self=yes ;; mingw* | pw32* | cegcc*) lt_cv_dlopen="LoadLibrary" lt_cv_dlopen_libs= ;; cygwin*) lt_cv_dlopen="dlopen" lt_cv_dlopen_libs= ;; darwin*) # if libdl is installed we need to link against it { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 $as_echo_n "checking for dlopen in -ldl... " >&6; } if ${ac_cv_lib_dl_dlopen+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-ldl $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ #ifdef __cplusplus extern "C" #endif char dlopen (); int main () { return dlopen (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ac_cv_lib_dl_dlopen=yes else ac_cv_lib_dl_dlopen=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 $as_echo "$ac_cv_lib_dl_dlopen" >&6; } if test "x$ac_cv_lib_dl_dlopen" = xyes; then : lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl" else lt_cv_dlopen="dyld" lt_cv_dlopen_libs= lt_cv_dlopen_self=yes fi ;; *) ac_fn_c_check_func "$LINENO" "shl_load" "ac_cv_func_shl_load" if test "x$ac_cv_func_shl_load" = xyes; then : lt_cv_dlopen="shl_load" else { $as_echo "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5 $as_echo_n "checking for shl_load in -ldld... " >&6; } if ${ac_cv_lib_dld_shl_load+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-ldld $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ #ifdef __cplusplus extern "C" #endif char shl_load (); int main () { return shl_load (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ac_cv_lib_dld_shl_load=yes else ac_cv_lib_dld_shl_load=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load" >&5 $as_echo "$ac_cv_lib_dld_shl_load" >&6; } if test "x$ac_cv_lib_dld_shl_load" = xyes; then : lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-ldld" else ac_fn_c_check_func "$LINENO" "dlopen" "ac_cv_func_dlopen" if test "x$ac_cv_func_dlopen" = xyes; then : lt_cv_dlopen="dlopen" else { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 $as_echo_n "checking for dlopen in -ldl... " >&6; } if ${ac_cv_lib_dl_dlopen+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-ldl $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ #ifdef __cplusplus extern "C" #endif char dlopen (); int main () { return dlopen (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ac_cv_lib_dl_dlopen=yes else ac_cv_lib_dl_dlopen=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 $as_echo "$ac_cv_lib_dl_dlopen" >&6; } if test "x$ac_cv_lib_dl_dlopen" = xyes; then : lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl" else { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lsvld" >&5 $as_echo_n "checking for dlopen in -lsvld... " >&6; } if ${ac_cv_lib_svld_dlopen+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lsvld $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ #ifdef __cplusplus extern "C" #endif char dlopen (); int main () { return dlopen (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ac_cv_lib_svld_dlopen=yes else ac_cv_lib_svld_dlopen=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_svld_dlopen" >&5 $as_echo "$ac_cv_lib_svld_dlopen" >&6; } if test "x$ac_cv_lib_svld_dlopen" = xyes; then : lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld" else { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dld_link in -ldld" >&5 $as_echo_n "checking for dld_link in -ldld... " >&6; } if ${ac_cv_lib_dld_dld_link+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-ldld $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ #ifdef __cplusplus extern "C" #endif char dld_link (); int main () { return dld_link (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ac_cv_lib_dld_dld_link=yes else ac_cv_lib_dld_dld_link=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_dld_link" >&5 $as_echo "$ac_cv_lib_dld_dld_link" >&6; } if test "x$ac_cv_lib_dld_dld_link" = xyes; then : lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-ldld" fi fi fi fi fi fi ;; esac if test "x$lt_cv_dlopen" != xno; then enable_dlopen=yes else enable_dlopen=no fi case $lt_cv_dlopen in dlopen) save_CPPFLAGS="$CPPFLAGS" test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H" save_LDFLAGS="$LDFLAGS" wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\" save_LIBS="$LIBS" LIBS="$lt_cv_dlopen_libs $LIBS" { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a program can dlopen itself" >&5 $as_echo_n "checking whether a program can dlopen itself... " >&6; } if ${lt_cv_dlopen_self+:} false; then : $as_echo_n "(cached) " >&6 else if test "$cross_compiling" = yes; then : lt_cv_dlopen_self=cross else lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 lt_status=$lt_dlunknown cat > conftest.$ac_ext <<_LT_EOF #line $LINENO "configure" #include "confdefs.h" #if HAVE_DLFCN_H #include #endif #include #ifdef RTLD_GLOBAL # define LT_DLGLOBAL RTLD_GLOBAL #else # ifdef DL_GLOBAL # define LT_DLGLOBAL DL_GLOBAL # else # define LT_DLGLOBAL 0 # endif #endif /* We may have to define LT_DLLAZY_OR_NOW in the command line if we find out it does not work in some platform. */ #ifndef LT_DLLAZY_OR_NOW # ifdef RTLD_LAZY # define LT_DLLAZY_OR_NOW RTLD_LAZY # else # ifdef DL_LAZY # define LT_DLLAZY_OR_NOW DL_LAZY # else # ifdef RTLD_NOW # define LT_DLLAZY_OR_NOW RTLD_NOW # else # ifdef DL_NOW # define LT_DLLAZY_OR_NOW DL_NOW # else # define LT_DLLAZY_OR_NOW 0 # endif # endif # endif # endif #endif /* When -fvisbility=hidden is used, assume the code has been annotated correspondingly for the symbols needed. */ #if defined(__GNUC__) && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3)) int fnord () __attribute__((visibility("default"))); #endif int fnord () { return 42; } int main () { void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW); int status = $lt_dlunknown; if (self) { if (dlsym (self,"fnord")) status = $lt_dlno_uscore; else { if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore; else puts (dlerror ()); } /* dlclose (self); */ } else puts (dlerror ()); return status; } _LT_EOF if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 (eval $ac_link) 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then (./conftest; exit; ) >&5 2>/dev/null lt_status=$? case x$lt_status in x$lt_dlno_uscore) lt_cv_dlopen_self=yes ;; x$lt_dlneed_uscore) lt_cv_dlopen_self=yes ;; x$lt_dlunknown|x*) lt_cv_dlopen_self=no ;; esac else : # compilation failed lt_cv_dlopen_self=no fi fi rm -fr conftest* fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self" >&5 $as_echo "$lt_cv_dlopen_self" >&6; } if test "x$lt_cv_dlopen_self" = xyes; then wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\" { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a statically linked program can dlopen itself" >&5 $as_echo_n "checking whether a statically linked program can dlopen itself... " >&6; } if ${lt_cv_dlopen_self_static+:} false; then : $as_echo_n "(cached) " >&6 else if test "$cross_compiling" = yes; then : lt_cv_dlopen_self_static=cross else lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 lt_status=$lt_dlunknown cat > conftest.$ac_ext <<_LT_EOF #line $LINENO "configure" #include "confdefs.h" #if HAVE_DLFCN_H #include #endif #include #ifdef RTLD_GLOBAL # define LT_DLGLOBAL RTLD_GLOBAL #else # ifdef DL_GLOBAL # define LT_DLGLOBAL DL_GLOBAL # else # define LT_DLGLOBAL 0 # endif #endif /* We may have to define LT_DLLAZY_OR_NOW in the command line if we find out it does not work in some platform. */ #ifndef LT_DLLAZY_OR_NOW # ifdef RTLD_LAZY # define LT_DLLAZY_OR_NOW RTLD_LAZY # else # ifdef DL_LAZY # define LT_DLLAZY_OR_NOW DL_LAZY # else # ifdef RTLD_NOW # define LT_DLLAZY_OR_NOW RTLD_NOW # else # ifdef DL_NOW # define LT_DLLAZY_OR_NOW DL_NOW # else # define LT_DLLAZY_OR_NOW 0 # endif # endif # endif # endif #endif /* When -fvisbility=hidden is used, assume the code has been annotated correspondingly for the symbols needed. */ #if defined(__GNUC__) && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3)) int fnord () __attribute__((visibility("default"))); #endif int fnord () { return 42; } int main () { void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW); int status = $lt_dlunknown; if (self) { if (dlsym (self,"fnord")) status = $lt_dlno_uscore; else { if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore; else puts (dlerror ()); } /* dlclose (self); */ } else puts (dlerror ()); return status; } _LT_EOF if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 (eval $ac_link) 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then (./conftest; exit; ) >&5 2>/dev/null lt_status=$? case x$lt_status in x$lt_dlno_uscore) lt_cv_dlopen_self_static=yes ;; x$lt_dlneed_uscore) lt_cv_dlopen_self_static=yes ;; x$lt_dlunknown|x*) lt_cv_dlopen_self_static=no ;; esac else : # compilation failed lt_cv_dlopen_self_static=no fi fi rm -fr conftest* fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self_static" >&5 $as_echo "$lt_cv_dlopen_self_static" >&6; } fi CPPFLAGS="$save_CPPFLAGS" LDFLAGS="$save_LDFLAGS" LIBS="$save_LIBS" ;; esac case $lt_cv_dlopen_self in yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;; *) enable_dlopen_self=unknown ;; esac case $lt_cv_dlopen_self_static in yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;; *) enable_dlopen_self_static=unknown ;; esac fi striplib= old_striplib= { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether stripping libraries is possible" >&5 $as_echo_n "checking whether stripping libraries is possible... " >&6; } if test -n "$STRIP" && $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then test -z "$old_striplib" && old_striplib="$STRIP --strip-debug" test -z "$striplib" && striplib="$STRIP --strip-unneeded" { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } else # FIXME - insert some real tests, host_os isn't really good enough case $host_os in darwin*) if test -n "$STRIP" ; then striplib="$STRIP -x" old_striplib="$STRIP -S" { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi ;; *) { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } ;; esac fi # Report which library types will actually be built { $as_echo "$as_me:${as_lineno-$LINENO}: checking if libtool supports shared libraries" >&5 $as_echo_n "checking if libtool supports shared libraries... " >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: result: $can_build_shared" >&5 $as_echo "$can_build_shared" >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build shared libraries" >&5 $as_echo_n "checking whether to build shared libraries... " >&6; } test "$can_build_shared" = "no" && enable_shared=no # On AIX, shared libraries and static libraries use the same namespace, and # are all built from PIC. case $host_os in aix3*) test "$enable_shared" = yes && enable_static=no if test -n "$RANLIB"; then archive_cmds="$archive_cmds~\$RANLIB \$lib" postinstall_cmds='$RANLIB $lib' fi ;; aix[4-9]*) if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then test "$enable_shared" = yes && enable_static=no fi ;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_shared" >&5 $as_echo "$enable_shared" >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build static libraries" >&5 $as_echo_n "checking whether to build static libraries... " >&6; } # Make sure either enable_shared or enable_static is yes. test "$enable_shared" = yes || enable_static=yes { $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_static" >&5 $as_echo "$enable_static" >&6; } fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu CC="$lt_save_CC" ac_config_commands="$ac_config_commands libtool" # Only expand once: ac_ext=cpp ac_cpp='$CXXCPP $CPPFLAGS' ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_cxx_compiler_gnu if test -z "$CXX"; then if test -n "$CCC"; then CXX=$CCC else if test -n "$ac_tool_prefix"; then for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC do # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. set dummy $ac_tool_prefix$ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CXX+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CXX"; then ac_cv_prog_CXX="$CXX" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_CXX="$ac_tool_prefix$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CXX=$ac_cv_prog_CXX if test -n "$CXX"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5 $as_echo "$CXX" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$CXX" && break done fi if test -z "$CXX"; then ac_ct_CXX=$CXX for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_CXX+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_CXX"; then ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CXX="$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_CXX=$ac_cv_prog_ac_ct_CXX if test -n "$ac_ct_CXX"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5 $as_echo "$ac_ct_CXX" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$ac_ct_CXX" && break done if test "x$ac_ct_CXX" = x; then CXX="g++" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CXX=$ac_ct_CXX fi fi fi fi # Provide some information about the compiler. $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5 set X $ac_compile ac_compiler=$2 for ac_option in --version -v -V -qversion; do { { ac_try="$ac_compiler $ac_option >&5" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compiler $ac_option >&5") 2>conftest.err ac_status=$? if test -s conftest.err; then sed '10a\ ... rest of stderr output deleted ... 10q' conftest.err >conftest.er1 cat conftest.er1 >&5 fi rm -f conftest.er1 conftest.err $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } done { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5 $as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; } if ${ac_cv_cxx_compiler_gnu+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { #ifndef __GNUC__ choke me #endif ; return 0; } _ACEOF if ac_fn_cxx_try_compile "$LINENO"; then : ac_compiler_gnu=yes else ac_compiler_gnu=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_cv_cxx_compiler_gnu=$ac_compiler_gnu fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5 $as_echo "$ac_cv_cxx_compiler_gnu" >&6; } if test $ac_compiler_gnu = yes; then GXX=yes else GXX= fi ac_test_CXXFLAGS=${CXXFLAGS+set} ac_save_CXXFLAGS=$CXXFLAGS { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5 $as_echo_n "checking whether $CXX accepts -g... " >&6; } if ${ac_cv_prog_cxx_g+:} false; then : $as_echo_n "(cached) " >&6 else ac_save_cxx_werror_flag=$ac_cxx_werror_flag ac_cxx_werror_flag=yes ac_cv_prog_cxx_g=no CXXFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_cxx_try_compile "$LINENO"; then : ac_cv_prog_cxx_g=yes else CXXFLAGS="" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_cxx_try_compile "$LINENO"; then : else ac_cxx_werror_flag=$ac_save_cxx_werror_flag CXXFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_cxx_try_compile "$LINENO"; then : ac_cv_prog_cxx_g=yes fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_cxx_werror_flag=$ac_save_cxx_werror_flag fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5 $as_echo "$ac_cv_prog_cxx_g" >&6; } if test "$ac_test_CXXFLAGS" = set; then CXXFLAGS=$ac_save_CXXFLAGS elif test $ac_cv_prog_cxx_g = yes; then if test "$GXX" = yes; then CXXFLAGS="-g -O2" else CXXFLAGS="-g" fi else if test "$GXX" = yes; then CXXFLAGS="-O2" else CXXFLAGS= fi fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu depcc="$CXX" am_compiler_list= { $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5 $as_echo_n "checking dependency style of $depcc... " >&6; } if ${am_cv_CXX_dependencies_compiler_type+:} false; then : $as_echo_n "(cached) " >&6 else if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then # We make a subdir and do the tests there. Otherwise we can end up # making bogus files that we don't know about and never remove. For # instance it was reported that on HP-UX the gcc test will end up # making a dummy file named 'D' -- because '-MD' means "put the output # in D". rm -rf conftest.dir mkdir conftest.dir # Copy depcomp to subdir because otherwise we won't find it if we're # using a relative directory. cp "$am_depcomp" conftest.dir cd conftest.dir # We will build objects and dependencies in a subdirectory because # it helps to detect inapplicable dependency modes. For instance # both Tru64's cc and ICC support -MD to output dependencies as a # side effect of compilation, but ICC will put the dependencies in # the current directory while Tru64 will put them in the object # directory. mkdir sub am_cv_CXX_dependencies_compiler_type=none if test "$am_compiler_list" = ""; then am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp` fi am__universal=false case " $depcc " in #( *\ -arch\ *\ -arch\ *) am__universal=true ;; esac for depmode in $am_compiler_list; do # Setup a source with many dependencies, because some compilers # like to wrap large dependency lists on column 80 (with \), and # we should not choose a depcomp mode which is confused by this. # # We need to recreate these files for each test, as the compiler may # overwrite some of them when testing with obscure command lines. # This happens at least with the AIX C compiler. : > sub/conftest.c for i in 1 2 3 4 5 6; do echo '#include "conftst'$i'.h"' >> sub/conftest.c # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with # Solaris 10 /bin/sh. echo '/* dummy */' > sub/conftst$i.h done echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf # We check with '-c' and '-o' for the sake of the "dashmstdout" # mode. It turns out that the SunPro C++ compiler does not properly # handle '-M -o', and we need to detect this. Also, some Intel # versions had trouble with output in subdirs. am__obj=sub/conftest.${OBJEXT-o} am__minus_obj="-o $am__obj" case $depmode in gcc) # This depmode causes a compiler race in universal mode. test "$am__universal" = false || continue ;; nosideeffect) # After this tag, mechanisms are not by side-effect, so they'll # only be used when explicitly requested. if test "x$enable_dependency_tracking" = xyes; then continue else break fi ;; msvc7 | msvc7msys | msvisualcpp | msvcmsys) # This compiler won't grok '-c -o', but also, the minuso test has # not run yet. These depmodes are late enough in the game, and # so weak that their functioning should not be impacted. am__obj=conftest.${OBJEXT-o} am__minus_obj= ;; none) break ;; esac if depmode=$depmode \ source=sub/conftest.c object=$am__obj \ depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \ $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \ >/dev/null 2>conftest.err && grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 && grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 && grep $am__obj sub/conftest.Po > /dev/null 2>&1 && ${MAKE-make} -s -f confmf > /dev/null 2>&1; then # icc doesn't choke on unknown options, it will just issue warnings # or remarks (even with -Werror). So we grep stderr for any message # that says an option was ignored or not supported. # When given -MP, icc 7.0 and 7.1 complain thusly: # icc: Command line warning: ignoring option '-M'; no argument required # The diagnosis changed in icc 8.0: # icc: Command line remark: option '-MP' not supported if (grep 'ignoring option' conftest.err || grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else am_cv_CXX_dependencies_compiler_type=$depmode break fi fi done cd .. rm -rf conftest.dir else am_cv_CXX_dependencies_compiler_type=none fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CXX_dependencies_compiler_type" >&5 $as_echo "$am_cv_CXX_dependencies_compiler_type" >&6; } CXXDEPMODE=depmode=$am_cv_CXX_dependencies_compiler_type if test "x$enable_dependency_tracking" != xno \ && test "$am_cv_CXX_dependencies_compiler_type" = gcc3; then am__fastdepCXX_TRUE= am__fastdepCXX_FALSE='#' else am__fastdepCXX_TRUE='#' am__fastdepCXX_FALSE= fi func_stripname_cnf () { case ${2} in .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;; *) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;; esac } # func_stripname_cnf if test -n "$CXX" && ( test "X$CXX" != "Xno" && ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) || (test "X$CXX" != "Xg++"))) ; then ac_ext=cpp ac_cpp='$CXXCPP $CPPFLAGS' ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_cxx_compiler_gnu { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5 $as_echo_n "checking how to run the C++ preprocessor... " >&6; } if test -z "$CXXCPP"; then if ${ac_cv_prog_CXXCPP+:} false; then : $as_echo_n "(cached) " >&6 else # Double quotes because CXXCPP needs to be expanded for CXXCPP in "$CXX -E" "/lib/cpp" do ac_preproc_ok=false for ac_cxx_preproc_warn_flag in '' yes do # Use a header file that comes with gcc, so configuring glibc # with a fresh cross-compiler works. # Prefer to if __STDC__ is defined, since # exists even on freestanding compilers. # On the NeXT, cc -E runs the code through the compiler's parser, # not just through cpp. "Syntax error" is here to catch this case. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifdef __STDC__ # include #else # include #endif Syntax error _ACEOF if ac_fn_cxx_try_cpp "$LINENO"; then : else # Broken: fails on valid input. continue fi rm -f conftest.err conftest.i conftest.$ac_ext # OK, works on sane cases. Now check whether nonexistent headers # can be detected and how. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if ac_fn_cxx_try_cpp "$LINENO"; then : # Broken: success on invalid input. continue else # Passes both tests. ac_preproc_ok=: break fi rm -f conftest.err conftest.i conftest.$ac_ext done # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. rm -f conftest.i conftest.err conftest.$ac_ext if $ac_preproc_ok; then : break fi done ac_cv_prog_CXXCPP=$CXXCPP fi CXXCPP=$ac_cv_prog_CXXCPP else ac_cv_prog_CXXCPP=$CXXCPP fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5 $as_echo "$CXXCPP" >&6; } ac_preproc_ok=false for ac_cxx_preproc_warn_flag in '' yes do # Use a header file that comes with gcc, so configuring glibc # with a fresh cross-compiler works. # Prefer to if __STDC__ is defined, since # exists even on freestanding compilers. # On the NeXT, cc -E runs the code through the compiler's parser, # not just through cpp. "Syntax error" is here to catch this case. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifdef __STDC__ # include #else # include #endif Syntax error _ACEOF if ac_fn_cxx_try_cpp "$LINENO"; then : else # Broken: fails on valid input. continue fi rm -f conftest.err conftest.i conftest.$ac_ext # OK, works on sane cases. Now check whether nonexistent headers # can be detected and how. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if ac_fn_cxx_try_cpp "$LINENO"; then : # Broken: success on invalid input. continue else # Passes both tests. ac_preproc_ok=: break fi rm -f conftest.err conftest.i conftest.$ac_ext done # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. rm -f conftest.i conftest.err conftest.$ac_ext if $ac_preproc_ok; then : else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "C++ preprocessor \"$CXXCPP\" fails sanity check See \`config.log' for more details" "$LINENO" 5; } fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu else _lt_caught_CXX_error=yes fi ac_ext=cpp ac_cpp='$CXXCPP $CPPFLAGS' ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_cxx_compiler_gnu archive_cmds_need_lc_CXX=no allow_undefined_flag_CXX= always_export_symbols_CXX=no archive_expsym_cmds_CXX= compiler_needs_object_CXX=no export_dynamic_flag_spec_CXX= hardcode_direct_CXX=no hardcode_direct_absolute_CXX=no hardcode_libdir_flag_spec_CXX= hardcode_libdir_flag_spec_ld_CXX= hardcode_libdir_separator_CXX= hardcode_minus_L_CXX=no hardcode_shlibpath_var_CXX=unsupported hardcode_automatic_CXX=no inherit_rpath_CXX=no module_cmds_CXX= module_expsym_cmds_CXX= link_all_deplibs_CXX=unknown old_archive_cmds_CXX=$old_archive_cmds reload_flag_CXX=$reload_flag reload_cmds_CXX=$reload_cmds no_undefined_flag_CXX= whole_archive_flag_spec_CXX= enable_shared_with_static_runtimes_CXX=no # Source file extension for C++ test sources. ac_ext=cpp # Object file extension for compiled C++ test sources. objext=o objext_CXX=$objext # No sense in running all these tests if we already determined that # the CXX compiler isn't working. Some variables (like enable_shared) # are currently assumed to apply to all compilers on this platform, # and will be corrupted by setting them based on a non-working compiler. if test "$_lt_caught_CXX_error" != yes; then # Code to be used in simple compile tests lt_simple_compile_test_code="int some_variable = 0;" # Code to be used in simple link tests lt_simple_link_test_code='int main(int, char *[]) { return(0); }' # ltmain only uses $CC for tagged configurations so make sure $CC is set. # If no C compiler was specified, use CC. LTCC=${LTCC-"$CC"} # If no C compiler flags were specified, use CFLAGS. LTCFLAGS=${LTCFLAGS-"$CFLAGS"} # Allow CC to be a program name with arguments. compiler=$CC # save warnings/boilerplate of simple test code ac_outfile=conftest.$ac_objext echo "$lt_simple_compile_test_code" >conftest.$ac_ext eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err _lt_compiler_boilerplate=`cat conftest.err` $RM conftest* ac_outfile=conftest.$ac_objext echo "$lt_simple_link_test_code" >conftest.$ac_ext eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err _lt_linker_boilerplate=`cat conftest.err` $RM -r conftest* # Allow CC to be a program name with arguments. lt_save_CC=$CC lt_save_CFLAGS=$CFLAGS lt_save_LD=$LD lt_save_GCC=$GCC GCC=$GXX lt_save_with_gnu_ld=$with_gnu_ld lt_save_path_LD=$lt_cv_path_LD if test -n "${lt_cv_prog_gnu_ldcxx+set}"; then lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx else $as_unset lt_cv_prog_gnu_ld fi if test -n "${lt_cv_path_LDCXX+set}"; then lt_cv_path_LD=$lt_cv_path_LDCXX else $as_unset lt_cv_path_LD fi test -z "${LDCXX+set}" || LD=$LDCXX CC=${CXX-"c++"} CFLAGS=$CXXFLAGS compiler=$CC compiler_CXX=$CC for cc_temp in $compiler""; do case $cc_temp in compile | *[\\/]compile | ccache | *[\\/]ccache ) ;; distcc | *[\\/]distcc | purify | *[\\/]purify ) ;; \-*) ;; *) break;; esac done cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"` if test -n "$compiler"; then # We don't want -fno-exception when compiling C++ code, so set the # no_builtin_flag separately if test "$GXX" = yes; then lt_prog_compiler_no_builtin_flag_CXX=' -fno-builtin' else lt_prog_compiler_no_builtin_flag_CXX= fi if test "$GXX" = yes; then # Set up default GNU C++ configuration # Check whether --with-gnu-ld was given. if test "${with_gnu_ld+set}" = set; then : withval=$with_gnu_ld; test "$withval" = no || with_gnu_ld=yes else with_gnu_ld=no fi ac_prog=ld if test "$GCC" = yes; then # Check if gcc -print-prog-name=ld gives a path. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5 $as_echo_n "checking for ld used by $CC... " >&6; } case $host in *-*-mingw*) # gcc leaves a trailing carriage return which upsets mingw ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; *) ac_prog=`($CC -print-prog-name=ld) 2>&5` ;; esac case $ac_prog in # Accept absolute paths. [\\/]* | ?:[\\/]*) re_direlt='/[^/][^/]*/\.\./' # Canonicalize the pathname of ld ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'` while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"` done test -z "$LD" && LD="$ac_prog" ;; "") # If it fails, then pretend we aren't using GCC. ac_prog=ld ;; *) # If it is relative, then search for the first ld in PATH. with_gnu_ld=unknown ;; esac elif test "$with_gnu_ld" = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5 $as_echo_n "checking for GNU ld... " >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5 $as_echo_n "checking for non-GNU ld... " >&6; } fi if ${lt_cv_path_LD+:} false; then : $as_echo_n "(cached) " >&6 else if test -z "$LD"; then lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR for ac_dir in $PATH; do IFS="$lt_save_ifs" test -z "$ac_dir" && ac_dir=. if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then lt_cv_path_LD="$ac_dir/$ac_prog" # Check to see if the program is GNU ld. I'd rather use --version, # but apparently some variants of GNU ld only accept -v. # Break only if it was the GNU/non-GNU ld that we prefer. case `"$lt_cv_path_LD" -v 2>&1 &5 $as_echo "$LD" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -z "$LD" && as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5 $as_echo_n "checking if the linker ($LD) is GNU ld... " >&6; } if ${lt_cv_prog_gnu_ld+:} false; then : $as_echo_n "(cached) " >&6 else # I'd rather use --version here, but apparently some GNU lds only accept -v. case `$LD -v 2>&1 &5 $as_echo "$lt_cv_prog_gnu_ld" >&6; } with_gnu_ld=$lt_cv_prog_gnu_ld # Check if GNU C++ uses GNU ld as the underlying linker, since the # archiving commands below assume that GNU ld is being used. if test "$with_gnu_ld" = yes; then archive_cmds_CXX='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' archive_expsym_cmds_CXX='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir' export_dynamic_flag_spec_CXX='${wl}--export-dynamic' # If archive_cmds runs LD, not CC, wlarc should be empty # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to # investigate it a little bit more. (MM) wlarc='${wl}' # ancient GNU ld didn't support --whole-archive et. al. if eval "`$CC -print-prog-name=ld` --help 2>&1" | $GREP 'no-whole-archive' > /dev/null; then whole_archive_flag_spec_CXX="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' else whole_archive_flag_spec_CXX= fi else with_gnu_ld=no wlarc= # A generic and very simple default shared library creation # command for GNU C++ for the case where it uses the native # linker, instead of GNU ld. If possible, this setting should # overridden to take advantage of the native linker features on # the platform it is being used on. archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib' fi # Commands to make compiler produce verbose output that lists # what "hidden" libraries, object files and flags are used when # linking a shared library. output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' else GXX=no with_gnu_ld=no wlarc= fi # PORTME: fill in a description of your system's C++ link characteristics { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 $as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; } ld_shlibs_CXX=yes case $host_os in aix3*) # FIXME: insert proper C++ library support ld_shlibs_CXX=no ;; aix[4-9]*) if test "$host_cpu" = ia64; then # On IA64, the linker does run time linking by default, so we don't # have to do anything special. aix_use_runtimelinking=no exp_sym_flag='-Bexport' no_entry_flag="" else aix_use_runtimelinking=no # Test if we are trying to use run time linking or normal # AIX style linking. If -brtl is somewhere in LDFLAGS, we # need to do runtime linking. case $host_os in aix4.[23]|aix4.[23].*|aix[5-9]*) for ld_flag in $LDFLAGS; do case $ld_flag in *-brtl*) aix_use_runtimelinking=yes break ;; esac done ;; esac exp_sym_flag='-bexport' no_entry_flag='-bnoentry' fi # When large executables or shared objects are built, AIX ld can # have problems creating the table of contents. If linking a library # or program results in "error TOC overflow" add -mminimal-toc to # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS. archive_cmds_CXX='' hardcode_direct_CXX=yes hardcode_direct_absolute_CXX=yes hardcode_libdir_separator_CXX=':' link_all_deplibs_CXX=yes file_list_spec_CXX='${wl}-f,' if test "$GXX" = yes; then case $host_os in aix4.[012]|aix4.[012].*) # We only want to do this on AIX 4.2 and lower, the check # below for broken collect2 doesn't work under 4.3+ collect2name=`${CC} -print-prog-name=collect2` if test -f "$collect2name" && strings "$collect2name" | $GREP resolve_lib_name >/dev/null then # We have reworked collect2 : else # We have old collect2 hardcode_direct_CXX=unsupported # It fails to find uninstalled libraries when the uninstalled # path is not listed in the libpath. Setting hardcode_minus_L # to unsupported forces relinking hardcode_minus_L_CXX=yes hardcode_libdir_flag_spec_CXX='-L$libdir' hardcode_libdir_separator_CXX= fi esac shared_flag='-shared' if test "$aix_use_runtimelinking" = yes; then shared_flag="$shared_flag "'${wl}-G' fi else # not using gcc if test "$host_cpu" = ia64; then # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release # chokes on -Wl,-G. The following line is correct: shared_flag='-G' else if test "$aix_use_runtimelinking" = yes; then shared_flag='${wl}-G' else shared_flag='${wl}-bM:SRE' fi fi fi export_dynamic_flag_spec_CXX='${wl}-bexpall' # It seems that -bexpall does not export symbols beginning with # underscore (_), so it is better to generate a list of symbols to # export. always_export_symbols_CXX=yes if test "$aix_use_runtimelinking" = yes; then # Warning - without using the other runtime loading flags (-brtl), # -berok will link without error, but may produce a broken library. allow_undefined_flag_CXX='-berok' # Determine the default libpath from the value encoded in an empty # executable. if test "${lt_cv_aix_libpath+set}" = set; then aix_libpath=$lt_cv_aix_libpath else if ${lt_cv_aix_libpath__CXX+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_cxx_try_link "$LINENO"; then : lt_aix_libpath_sed=' /Import File Strings/,/^$/ { /^0/ { s/^0 *\([^ ]*\) *$/\1/ p } }' lt_cv_aix_libpath__CXX=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` # Check for a 64-bit object if we didn't find anything. if test -z "$lt_cv_aix_libpath__CXX"; then lt_cv_aix_libpath__CXX=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` fi fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext if test -z "$lt_cv_aix_libpath__CXX"; then lt_cv_aix_libpath__CXX="/usr/lib:/lib" fi fi aix_libpath=$lt_cv_aix_libpath__CXX fi hardcode_libdir_flag_spec_CXX='${wl}-blibpath:$libdir:'"$aix_libpath" archive_expsym_cmds_CXX='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag" else if test "$host_cpu" = ia64; then hardcode_libdir_flag_spec_CXX='${wl}-R $libdir:/usr/lib:/lib' allow_undefined_flag_CXX="-z nodefs" archive_expsym_cmds_CXX="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols" else # Determine the default libpath from the value encoded in an # empty executable. if test "${lt_cv_aix_libpath+set}" = set; then aix_libpath=$lt_cv_aix_libpath else if ${lt_cv_aix_libpath__CXX+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_cxx_try_link "$LINENO"; then : lt_aix_libpath_sed=' /Import File Strings/,/^$/ { /^0/ { s/^0 *\([^ ]*\) *$/\1/ p } }' lt_cv_aix_libpath__CXX=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` # Check for a 64-bit object if we didn't find anything. if test -z "$lt_cv_aix_libpath__CXX"; then lt_cv_aix_libpath__CXX=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` fi fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext if test -z "$lt_cv_aix_libpath__CXX"; then lt_cv_aix_libpath__CXX="/usr/lib:/lib" fi fi aix_libpath=$lt_cv_aix_libpath__CXX fi hardcode_libdir_flag_spec_CXX='${wl}-blibpath:$libdir:'"$aix_libpath" # Warning - without using the other run time loading flags, # -berok will link without error, but may produce a broken library. no_undefined_flag_CXX=' ${wl}-bernotok' allow_undefined_flag_CXX=' ${wl}-berok' if test "$with_gnu_ld" = yes; then # We only use this code for GNU lds that support --whole-archive. whole_archive_flag_spec_CXX='${wl}--whole-archive$convenience ${wl}--no-whole-archive' else # Exported symbols can be pulled into shared objects from archives whole_archive_flag_spec_CXX='$convenience' fi archive_cmds_need_lc_CXX=yes # This is similar to how AIX traditionally builds its shared # libraries. archive_expsym_cmds_CXX="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname' fi fi ;; beos*) if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then allow_undefined_flag_CXX=unsupported # Joseph Beckenbach says some releases of gcc # support --undefined. This deserves some investigation. FIXME archive_cmds_CXX='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' else ld_shlibs_CXX=no fi ;; chorus*) case $cc_basename in *) # FIXME: insert proper C++ library support ld_shlibs_CXX=no ;; esac ;; cygwin* | mingw* | pw32* | cegcc*) case $GXX,$cc_basename in ,cl* | no,cl*) # Native MSVC # hardcode_libdir_flag_spec is actually meaningless, as there is # no search path for DLLs. hardcode_libdir_flag_spec_CXX=' ' allow_undefined_flag_CXX=unsupported always_export_symbols_CXX=yes file_list_spec_CXX='@' # Tell ltmain to make .lib files, not .a files. libext=lib # Tell ltmain to make .dll files, not .so files. shrext_cmds=".dll" # FIXME: Setting linknames here is a bad hack. archive_cmds_CXX='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames=' archive_expsym_cmds_CXX='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then $SED -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp; else $SED -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp; fi~ $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~ linknames=' # The linker will not automatically build a static lib if we build a DLL. # _LT_TAGVAR(old_archive_from_new_cmds, CXX)='true' enable_shared_with_static_runtimes_CXX=yes # Don't use ranlib old_postinstall_cmds_CXX='chmod 644 $oldlib' postlink_cmds_CXX='lt_outputfile="@OUTPUT@"~ lt_tool_outputfile="@TOOL_OUTPUT@"~ case $lt_outputfile in *.exe|*.EXE) ;; *) lt_outputfile="$lt_outputfile.exe" lt_tool_outputfile="$lt_tool_outputfile.exe" ;; esac~ func_to_tool_file "$lt_outputfile"~ if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1; $RM "$lt_outputfile.manifest"; fi' ;; *) # g++ # _LT_TAGVAR(hardcode_libdir_flag_spec, CXX) is actually meaningless, # as there is no search path for DLLs. hardcode_libdir_flag_spec_CXX='-L$libdir' export_dynamic_flag_spec_CXX='${wl}--export-all-symbols' allow_undefined_flag_CXX=unsupported always_export_symbols_CXX=no enable_shared_with_static_runtimes_CXX=yes if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' # If the export-symbols file already is a .def file (1st line # is EXPORTS), use it as is; otherwise, prepend... archive_expsym_cmds_CXX='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then cp $export_symbols $output_objdir/$soname.def; else echo EXPORTS > $output_objdir/$soname.def; cat $export_symbols >> $output_objdir/$soname.def; fi~ $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' else ld_shlibs_CXX=no fi ;; esac ;; darwin* | rhapsody*) archive_cmds_need_lc_CXX=no hardcode_direct_CXX=no hardcode_automatic_CXX=yes hardcode_shlibpath_var_CXX=unsupported if test "$lt_cv_ld_force_load" = "yes"; then whole_archive_flag_spec_CXX='`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience ${wl}-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`' else whole_archive_flag_spec_CXX='' fi link_all_deplibs_CXX=yes allow_undefined_flag_CXX="$_lt_dar_allow_undefined" case $cc_basename in ifort*) _lt_dar_can_shared=yes ;; *) _lt_dar_can_shared=$GCC ;; esac if test "$_lt_dar_can_shared" = "yes"; then output_verbose_link_cmd=func_echo_all archive_cmds_CXX="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod${_lt_dsymutil}" module_cmds_CXX="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dsymutil}" archive_expsym_cmds_CXX="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring ${_lt_dar_single_mod}${_lt_dar_export_syms}${_lt_dsymutil}" module_expsym_cmds_CXX="sed -e 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dar_export_syms}${_lt_dsymutil}" if test "$lt_cv_apple_cc_single_mod" != "yes"; then archive_cmds_CXX="\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dsymutil}" archive_expsym_cmds_CXX="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dar_export_syms}${_lt_dsymutil}" fi else ld_shlibs_CXX=no fi ;; dgux*) case $cc_basename in ec++*) # FIXME: insert proper C++ library support ld_shlibs_CXX=no ;; ghcx*) # Green Hills C++ Compiler # FIXME: insert proper C++ library support ld_shlibs_CXX=no ;; *) # FIXME: insert proper C++ library support ld_shlibs_CXX=no ;; esac ;; freebsd[12]*) # C++ shared libraries reported to be fairly broken before # switch to ELF ld_shlibs_CXX=no ;; freebsd-elf*) archive_cmds_need_lc_CXX=no ;; freebsd* | dragonfly*) # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF # conventions ld_shlibs_CXX=yes ;; gnu*) ;; haiku*) archive_cmds_CXX='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' link_all_deplibs_CXX=yes ;; hpux9*) hardcode_libdir_flag_spec_CXX='${wl}+b ${wl}$libdir' hardcode_libdir_separator_CXX=: export_dynamic_flag_spec_CXX='${wl}-E' hardcode_direct_CXX=yes hardcode_minus_L_CXX=yes # Not in the search PATH, # but as the default # location of the library. case $cc_basename in CC*) # FIXME: insert proper C++ library support ld_shlibs_CXX=no ;; aCC*) archive_cmds_CXX='$RM $output_objdir/$soname~$CC -b ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' # Commands to make compiler produce verbose output that lists # what "hidden" libraries, object files and flags are used when # linking a shared library. # # There doesn't appear to be a way to prevent this compiler from # explicitly linking system object files so we need to strip them # from the output so that they don't get included in the library # dependencies. output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' ;; *) if test "$GXX" = yes; then archive_cmds_CXX='$RM $output_objdir/$soname~$CC -shared -nostdlib $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' else # FIXME: insert proper C++ library support ld_shlibs_CXX=no fi ;; esac ;; hpux10*|hpux11*) if test $with_gnu_ld = no; then hardcode_libdir_flag_spec_CXX='${wl}+b ${wl}$libdir' hardcode_libdir_separator_CXX=: case $host_cpu in hppa*64*|ia64*) ;; *) export_dynamic_flag_spec_CXX='${wl}-E' ;; esac fi case $host_cpu in hppa*64*|ia64*) hardcode_direct_CXX=no hardcode_shlibpath_var_CXX=no ;; *) hardcode_direct_CXX=yes hardcode_direct_absolute_CXX=yes hardcode_minus_L_CXX=yes # Not in the search PATH, # but as the default # location of the library. ;; esac case $cc_basename in CC*) # FIXME: insert proper C++ library support ld_shlibs_CXX=no ;; aCC*) case $host_cpu in hppa*64*) archive_cmds_CXX='$CC -b ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' ;; ia64*) archive_cmds_CXX='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' ;; *) archive_cmds_CXX='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' ;; esac # Commands to make compiler produce verbose output that lists # what "hidden" libraries, object files and flags are used when # linking a shared library. # # There doesn't appear to be a way to prevent this compiler from # explicitly linking system object files so we need to strip them # from the output so that they don't get included in the library # dependencies. output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' ;; *) if test "$GXX" = yes; then if test $with_gnu_ld = no; then case $host_cpu in hppa*64*) archive_cmds_CXX='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' ;; ia64*) archive_cmds_CXX='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' ;; *) archive_cmds_CXX='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' ;; esac fi else # FIXME: insert proper C++ library support ld_shlibs_CXX=no fi ;; esac ;; interix[3-9]*) hardcode_direct_CXX=no hardcode_shlibpath_var_CXX=no hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir' export_dynamic_flag_spec_CXX='${wl}-E' # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc. # Instead, shared libraries are loaded at an image base (0x10000000 by # default) and relocated if they conflict, which is a slow very memory # consuming and fragmenting process. To avoid this, we pick a random, # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link # time. Moving up from 0x10000000 also allows more sbrk(2) space. archive_cmds_CXX='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' archive_expsym_cmds_CXX='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' ;; irix5* | irix6*) case $cc_basename in CC*) # SGI C++ archive_cmds_CXX='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' # Archives containing C++ object files must be created using # "CC -ar", where "CC" is the IRIX C++ compiler. This is # necessary to make sure instantiated templates are included # in the archive. old_archive_cmds_CXX='$CC -ar -WR,-u -o $oldlib $oldobjs' ;; *) if test "$GXX" = yes; then if test "$with_gnu_ld" = no; then archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' else archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` -o $lib' fi fi link_all_deplibs_CXX=yes ;; esac hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir' hardcode_libdir_separator_CXX=: inherit_rpath_CXX=yes ;; linux* | k*bsd*-gnu | kopensolaris*-gnu) case $cc_basename in KCC*) # Kuck and Associates, Inc. (KAI) C++ Compiler # KCC will only create a shared library if the output file # ends with ".so" (or ".sl" for HP-UX), so rename the library # to its proper name (with version) after linking. archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' archive_expsym_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib ${wl}-retain-symbols-file,$export_symbols; mv \$templib $lib' # Commands to make compiler produce verbose output that lists # what "hidden" libraries, object files and flags are used when # linking a shared library. # # There doesn't appear to be a way to prevent this compiler from # explicitly linking system object files so we need to strip them # from the output so that they don't get included in the library # dependencies. output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | $GREP "ld"`; rm -f libconftest$shared_ext; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir' export_dynamic_flag_spec_CXX='${wl}--export-dynamic' # Archives containing C++ object files must be created using # "CC -Bstatic", where "CC" is the KAI C++ compiler. old_archive_cmds_CXX='$CC -Bstatic -o $oldlib $oldobjs' ;; icpc* | ecpc* ) # Intel C++ with_gnu_ld=yes # version 8.0 and above of icpc choke on multiply defined symbols # if we add $predep_objects and $postdep_objects, however 7.1 and # earlier do not add the objects themselves. case `$CC -V 2>&1` in *"Version 7."*) archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' archive_expsym_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' ;; *) # Version 8.0 or newer tmp_idyn= case $host_cpu in ia64*) tmp_idyn=' -i_dynamic';; esac archive_cmds_CXX='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' archive_expsym_cmds_CXX='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' ;; esac archive_cmds_need_lc_CXX=no hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir' export_dynamic_flag_spec_CXX='${wl}--export-dynamic' whole_archive_flag_spec_CXX='${wl}--whole-archive$convenience ${wl}--no-whole-archive' ;; pgCC* | pgcpp*) # Portland Group C++ compiler case `$CC -V` in *pgCC\ [1-5].* | *pgcpp\ [1-5].*) prelink_cmds_CXX='tpldir=Template.dir~ rm -rf $tpldir~ $CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~ compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"' old_archive_cmds_CXX='tpldir=Template.dir~ rm -rf $tpldir~ $CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~ $AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~ $RANLIB $oldlib' archive_cmds_CXX='tpldir=Template.dir~ rm -rf $tpldir~ $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~ $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib' archive_expsym_cmds_CXX='tpldir=Template.dir~ rm -rf $tpldir~ $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~ $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib' ;; *) # Version 6 and above use weak symbols archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib' archive_expsym_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib' ;; esac hardcode_libdir_flag_spec_CXX='${wl}--rpath ${wl}$libdir' export_dynamic_flag_spec_CXX='${wl}--export-dynamic' whole_archive_flag_spec_CXX='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' ;; cxx*) # Compaq C++ archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' archive_expsym_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib ${wl}-retain-symbols-file $wl$export_symbols' runpath_var=LD_RUN_PATH hardcode_libdir_flag_spec_CXX='-rpath $libdir' hardcode_libdir_separator_CXX=: # Commands to make compiler produce verbose output that lists # what "hidden" libraries, object files and flags are used when # linking a shared library. # # There doesn't appear to be a way to prevent this compiler from # explicitly linking system object files so we need to strip them # from the output so that they don't get included in the library # dependencies. output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "X$list" | $Xsed' ;; xl* | mpixl* | bgxl*) # IBM XL 8.0 on PPC, with GNU ld hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir' export_dynamic_flag_spec_CXX='${wl}--export-dynamic' archive_cmds_CXX='$CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' if test "x$supports_anon_versioning" = xyes; then archive_expsym_cmds_CXX='echo "{ global:" > $output_objdir/$libname.ver~ cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ echo "local: *; };" >> $output_objdir/$libname.ver~ $CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib' fi ;; *) case `$CC -V 2>&1 | sed 5q` in *Sun\ C*) # Sun C++ 5.9 no_undefined_flag_CXX=' -zdefs' archive_cmds_CXX='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' archive_expsym_cmds_CXX='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file ${wl}$export_symbols' hardcode_libdir_flag_spec_CXX='-R$libdir' whole_archive_flag_spec_CXX='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' compiler_needs_object_CXX=yes # Not sure whether something based on # $CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 # would be better. output_verbose_link_cmd='func_echo_all' # Archives containing C++ object files must be created using # "CC -xar", where "CC" is the Sun C++ compiler. This is # necessary to make sure instantiated templates are included # in the archive. old_archive_cmds_CXX='$CC -xar -o $oldlib $oldobjs' ;; esac ;; esac ;; lynxos*) # FIXME: insert proper C++ library support ld_shlibs_CXX=no ;; m88k*) # FIXME: insert proper C++ library support ld_shlibs_CXX=no ;; mvs*) case $cc_basename in cxx*) # FIXME: insert proper C++ library support ld_shlibs_CXX=no ;; *) # FIXME: insert proper C++ library support ld_shlibs_CXX=no ;; esac ;; netbsd*) if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then archive_cmds_CXX='$LD -Bshareable -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags' wlarc= hardcode_libdir_flag_spec_CXX='-R$libdir' hardcode_direct_CXX=yes hardcode_shlibpath_var_CXX=no fi # Workaround some broken pre-1.5 toolchains output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"' ;; *nto* | *qnx*) ld_shlibs_CXX=yes ;; openbsd2*) # C++ shared libraries are fairly broken ld_shlibs_CXX=no ;; openbsd*) if test -f /usr/libexec/ld.so; then hardcode_direct_CXX=yes hardcode_shlibpath_var_CXX=no hardcode_direct_absolute_CXX=yes archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib' hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir' if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then archive_expsym_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file,$export_symbols -o $lib' export_dynamic_flag_spec_CXX='${wl}-E' whole_archive_flag_spec_CXX="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' fi output_verbose_link_cmd=func_echo_all else ld_shlibs_CXX=no fi ;; osf3* | osf4* | osf5*) case $cc_basename in KCC*) # Kuck and Associates, Inc. (KAI) C++ Compiler # KCC will only create a shared library if the output file # ends with ".so" (or ".sl" for HP-UX), so rename the library # to its proper name (with version) after linking. archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo "$lib" | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir' hardcode_libdir_separator_CXX=: # Archives containing C++ object files must be created using # the KAI C++ compiler. case $host in osf3*) old_archive_cmds_CXX='$CC -Bstatic -o $oldlib $oldobjs' ;; *) old_archive_cmds_CXX='$CC -o $oldlib $oldobjs' ;; esac ;; RCC*) # Rational C++ 2.4.1 # FIXME: insert proper C++ library support ld_shlibs_CXX=no ;; cxx*) case $host in osf3*) allow_undefined_flag_CXX=' ${wl}-expect_unresolved ${wl}\*' archive_cmds_CXX='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && func_echo_all "${wl}-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir' ;; *) allow_undefined_flag_CXX=' -expect_unresolved \*' archive_cmds_CXX='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' archive_expsym_cmds_CXX='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~ echo "-hidden">> $lib.exp~ $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname ${wl}-input ${wl}$lib.exp `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~ $RM $lib.exp' hardcode_libdir_flag_spec_CXX='-rpath $libdir' ;; esac hardcode_libdir_separator_CXX=: # Commands to make compiler produce verbose output that lists # what "hidden" libraries, object files and flags are used when # linking a shared library. # # There doesn't appear to be a way to prevent this compiler from # explicitly linking system object files so we need to strip them # from the output so that they don't get included in the library # dependencies. output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' ;; *) if test "$GXX" = yes && test "$with_gnu_ld" = no; then allow_undefined_flag_CXX=' ${wl}-expect_unresolved ${wl}\*' case $host in osf3*) archive_cmds_CXX='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' ;; *) archive_cmds_CXX='$CC -shared $pic_flag -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' ;; esac hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir' hardcode_libdir_separator_CXX=: # Commands to make compiler produce verbose output that lists # what "hidden" libraries, object files and flags are used when # linking a shared library. output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' else # FIXME: insert proper C++ library support ld_shlibs_CXX=no fi ;; esac ;; psos*) # FIXME: insert proper C++ library support ld_shlibs_CXX=no ;; sunos4*) case $cc_basename in CC*) # Sun C++ 4.x # FIXME: insert proper C++ library support ld_shlibs_CXX=no ;; lcc*) # Lucid # FIXME: insert proper C++ library support ld_shlibs_CXX=no ;; *) # FIXME: insert proper C++ library support ld_shlibs_CXX=no ;; esac ;; solaris*) case $cc_basename in CC* | sunCC*) # Sun C++ 4.2, 5.x and Centerline C++ archive_cmds_need_lc_CXX=yes no_undefined_flag_CXX=' -zdefs' archive_cmds_CXX='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' archive_expsym_cmds_CXX='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ $CC -G${allow_undefined_flag} ${wl}-M ${wl}$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' hardcode_libdir_flag_spec_CXX='-R$libdir' hardcode_shlibpath_var_CXX=no case $host_os in solaris2.[0-5] | solaris2.[0-5].*) ;; *) # The compiler driver will combine and reorder linker options, # but understands `-z linker_flag'. # Supported since Solaris 2.6 (maybe 2.5.1?) whole_archive_flag_spec_CXX='-z allextract$convenience -z defaultextract' ;; esac link_all_deplibs_CXX=yes output_verbose_link_cmd='func_echo_all' # Archives containing C++ object files must be created using # "CC -xar", where "CC" is the Sun C++ compiler. This is # necessary to make sure instantiated templates are included # in the archive. old_archive_cmds_CXX='$CC -xar -o $oldlib $oldobjs' ;; gcx*) # Green Hills C++ Compiler archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' # The C++ compiler must be used to create the archive. old_archive_cmds_CXX='$CC $LDFLAGS -archive -o $oldlib $oldobjs' ;; *) # GNU C++ compiler with Solaris linker if test "$GXX" = yes && test "$with_gnu_ld" = no; then no_undefined_flag_CXX=' ${wl}-z ${wl}defs' if $CC --version | $GREP -v '^2\.7' > /dev/null; then archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' archive_expsym_cmds_CXX='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ $CC -shared $pic_flag -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' # Commands to make compiler produce verbose output that lists # what "hidden" libraries, object files and flags are used when # linking a shared library. output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' else # g++ 2.7 appears to require `-G' NOT `-shared' on this # platform. archive_cmds_CXX='$CC -G -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' archive_expsym_cmds_CXX='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ $CC -G -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' # Commands to make compiler produce verbose output that lists # what "hidden" libraries, object files and flags are used when # linking a shared library. output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' fi hardcode_libdir_flag_spec_CXX='${wl}-R $wl$libdir' case $host_os in solaris2.[0-5] | solaris2.[0-5].*) ;; *) whole_archive_flag_spec_CXX='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract' ;; esac fi ;; esac ;; sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7* | sco3.2v5.0.[024]*) no_undefined_flag_CXX='${wl}-z,text' archive_cmds_need_lc_CXX=no hardcode_shlibpath_var_CXX=no runpath_var='LD_RUN_PATH' case $cc_basename in CC*) archive_cmds_CXX='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' archive_expsym_cmds_CXX='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' ;; *) archive_cmds_CXX='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' archive_expsym_cmds_CXX='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' ;; esac ;; sysv5* | sco3.2v5* | sco5v6*) # Note: We can NOT use -z defs as we might desire, because we do not # link with -lc, and that would cause any symbols used from libc to # always be unresolved, which means just about no library would # ever link correctly. If we're not using GNU ld we use -z text # though, which does catch some bad symbols but isn't as heavy-handed # as -z defs. no_undefined_flag_CXX='${wl}-z,text' allow_undefined_flag_CXX='${wl}-z,nodefs' archive_cmds_need_lc_CXX=no hardcode_shlibpath_var_CXX=no hardcode_libdir_flag_spec_CXX='${wl}-R,$libdir' hardcode_libdir_separator_CXX=':' link_all_deplibs_CXX=yes export_dynamic_flag_spec_CXX='${wl}-Bexport' runpath_var='LD_RUN_PATH' case $cc_basename in CC*) archive_cmds_CXX='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' archive_expsym_cmds_CXX='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' old_archive_cmds_CXX='$CC -Tprelink_objects $oldobjs~ '"$old_archive_cmds_CXX" reload_cmds_CXX='$CC -Tprelink_objects $reload_objs~ '"$reload_cmds_CXX" ;; *) archive_cmds_CXX='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' archive_expsym_cmds_CXX='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' ;; esac ;; tandem*) case $cc_basename in NCC*) # NonStop-UX NCC 3.20 # FIXME: insert proper C++ library support ld_shlibs_CXX=no ;; *) # FIXME: insert proper C++ library support ld_shlibs_CXX=no ;; esac ;; vxworks*) # FIXME: insert proper C++ library support ld_shlibs_CXX=no ;; *) # FIXME: insert proper C++ library support ld_shlibs_CXX=no ;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5 $as_echo "$ld_shlibs_CXX" >&6; } test "$ld_shlibs_CXX" = no && can_build_shared=no GCC_CXX="$GXX" LD_CXX="$LD" ## CAVEAT EMPTOR: ## There is no encapsulation within the following macros, do not change ## the running order or otherwise move them around unless you know exactly ## what you are doing... # Dependencies to place before and after the object being linked: predep_objects_CXX= postdep_objects_CXX= predeps_CXX= postdeps_CXX= compiler_lib_search_path_CXX= cat > conftest.$ac_ext <<_LT_EOF class Foo { public: Foo (void) { a = 0; } private: int a; }; _LT_EOF _lt_libdeps_save_CFLAGS=$CFLAGS case "$CC $CFLAGS " in #( *\ -flto*\ *) CFLAGS="$CFLAGS -fno-lto" ;; *\ -fwhopr*\ *) CFLAGS="$CFLAGS -fno-whopr" ;; esac if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 (eval $ac_compile) 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then # Parse the compiler output and extract the necessary # objects, libraries and library flags. # Sentinel used to keep track of whether or not we are before # the conftest object file. pre_test_object_deps_done=no for p in `eval "$output_verbose_link_cmd"`; do case ${prev}${p} in -L* | -R* | -l*) # Some compilers place space between "-{L,R}" and the path. # Remove the space. if test $p = "-L" || test $p = "-R"; then prev=$p continue fi # Expand the sysroot to ease extracting the directories later. if test -z "$prev"; then case $p in -L*) func_stripname_cnf '-L' '' "$p"; prev=-L; p=$func_stripname_result ;; -R*) func_stripname_cnf '-R' '' "$p"; prev=-R; p=$func_stripname_result ;; -l*) func_stripname_cnf '-l' '' "$p"; prev=-l; p=$func_stripname_result ;; esac fi case $p in =*) func_stripname_cnf '=' '' "$p"; p=$lt_sysroot$func_stripname_result ;; esac if test "$pre_test_object_deps_done" = no; then case ${prev} in -L | -R) # Internal compiler library paths should come after those # provided the user. The postdeps already come after the # user supplied libs so there is no need to process them. if test -z "$compiler_lib_search_path_CXX"; then compiler_lib_search_path_CXX="${prev}${p}" else compiler_lib_search_path_CXX="${compiler_lib_search_path_CXX} ${prev}${p}" fi ;; # The "-l" case would never come before the object being # linked, so don't bother handling this case. esac else if test -z "$postdeps_CXX"; then postdeps_CXX="${prev}${p}" else postdeps_CXX="${postdeps_CXX} ${prev}${p}" fi fi prev= ;; *.lto.$objext) ;; # Ignore GCC LTO objects *.$objext) # This assumes that the test object file only shows up # once in the compiler output. if test "$p" = "conftest.$objext"; then pre_test_object_deps_done=yes continue fi if test "$pre_test_object_deps_done" = no; then if test -z "$predep_objects_CXX"; then predep_objects_CXX="$p" else predep_objects_CXX="$predep_objects_CXX $p" fi else if test -z "$postdep_objects_CXX"; then postdep_objects_CXX="$p" else postdep_objects_CXX="$postdep_objects_CXX $p" fi fi ;; *) ;; # Ignore the rest. esac done # Clean up. rm -f a.out a.exe else echo "libtool.m4: error: problem compiling CXX test program" fi $RM -f confest.$objext CFLAGS=$_lt_libdeps_save_CFLAGS # PORTME: override above test on systems where it is broken case $host_os in interix[3-9]*) # Interix 3.5 installs completely hosed .la files for C++, so rather than # hack all around it, let's just trust "g++" to DTRT. predep_objects_CXX= postdep_objects_CXX= postdeps_CXX= ;; linux*) case `$CC -V 2>&1 | sed 5q` in *Sun\ C*) # Sun C++ 5.9 # The more standards-conforming stlport4 library is # incompatible with the Cstd library. Avoid specifying # it if it's in CXXFLAGS. Ignore libCrun as # -library=stlport4 depends on it. case " $CXX $CXXFLAGS " in *" -library=stlport4 "*) solaris_use_stlport4=yes ;; esac if test "$solaris_use_stlport4" != yes; then postdeps_CXX='-library=Cstd -library=Crun' fi ;; esac ;; solaris*) case $cc_basename in CC* | sunCC*) # The more standards-conforming stlport4 library is # incompatible with the Cstd library. Avoid specifying # it if it's in CXXFLAGS. Ignore libCrun as # -library=stlport4 depends on it. case " $CXX $CXXFLAGS " in *" -library=stlport4 "*) solaris_use_stlport4=yes ;; esac # Adding this requires a known-good setup of shared libraries for # Sun compiler versions before 5.6, else PIC objects from an old # archive will be linked into the output, leading to subtle bugs. if test "$solaris_use_stlport4" != yes; then postdeps_CXX='-library=Cstd -library=Crun' fi ;; esac ;; esac case " $postdeps_CXX " in *" -lc "*) archive_cmds_need_lc_CXX=no ;; esac compiler_lib_search_dirs_CXX= if test -n "${compiler_lib_search_path_CXX}"; then compiler_lib_search_dirs_CXX=`echo " ${compiler_lib_search_path_CXX}" | ${SED} -e 's! -L! !g' -e 's!^ !!'` fi lt_prog_compiler_wl_CXX= lt_prog_compiler_pic_CXX= lt_prog_compiler_static_CXX= # C++ specific cases for pic, static, wl, etc. if test "$GXX" = yes; then lt_prog_compiler_wl_CXX='-Wl,' lt_prog_compiler_static_CXX='-static' case $host_os in aix*) # All AIX code is PIC. if test "$host_cpu" = ia64; then # AIX 5 now supports IA64 processor lt_prog_compiler_static_CXX='-Bstatic' fi ;; amigaos*) case $host_cpu in powerpc) # see comment about AmigaOS4 .so support lt_prog_compiler_pic_CXX='-fPIC' ;; m68k) # FIXME: we need at least 68020 code to build shared libraries, but # adding the `-m68020' flag to GCC prevents building anything better, # like `-m68040'. lt_prog_compiler_pic_CXX='-m68020 -resident32 -malways-restore-a4' ;; esac ;; beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*) # PIC is the default for these OSes. ;; mingw* | cygwin* | os2* | pw32* | cegcc*) # This hack is so that the source file can tell whether it is being # built for inclusion in a dll (and should export symbols for example). # Although the cygwin gcc ignores -fPIC, still need this for old-style # (--disable-auto-import) libraries lt_prog_compiler_pic_CXX='-DDLL_EXPORT' ;; darwin* | rhapsody*) # PIC is the default on this platform # Common symbols not allowed in MH_DYLIB files lt_prog_compiler_pic_CXX='-fno-common' ;; *djgpp*) # DJGPP does not support shared libraries at all lt_prog_compiler_pic_CXX= ;; haiku*) # PIC is the default for Haiku. # The "-static" flag exists, but is broken. lt_prog_compiler_static_CXX= ;; interix[3-9]*) # Interix 3.x gcc -fpic/-fPIC options generate broken code. # Instead, we relocate shared libraries at runtime. ;; sysv4*MP*) if test -d /usr/nec; then lt_prog_compiler_pic_CXX=-Kconform_pic fi ;; hpux*) # PIC is the default for 64-bit PA HP-UX, but not for 32-bit # PA HP-UX. On IA64 HP-UX, PIC is the default but the pic flag # sets the default TLS model and affects inlining. case $host_cpu in hppa*64*) ;; *) lt_prog_compiler_pic_CXX='-fPIC' ;; esac ;; *qnx* | *nto*) # QNX uses GNU C++, but need to define -shared option too, otherwise # it will coredump. lt_prog_compiler_pic_CXX='-fPIC -shared' ;; *) lt_prog_compiler_pic_CXX='-fPIC' ;; esac else case $host_os in aix[4-9]*) # All AIX code is PIC. if test "$host_cpu" = ia64; then # AIX 5 now supports IA64 processor lt_prog_compiler_static_CXX='-Bstatic' else lt_prog_compiler_static_CXX='-bnso -bI:/lib/syscalls.exp' fi ;; chorus*) case $cc_basename in cxch68*) # Green Hills C++ Compiler # _LT_TAGVAR(lt_prog_compiler_static, CXX)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a" ;; esac ;; mingw* | cygwin* | os2* | pw32* | cegcc*) # This hack is so that the source file can tell whether it is being # built for inclusion in a dll (and should export symbols for example). lt_prog_compiler_pic_CXX='-DDLL_EXPORT' ;; dgux*) case $cc_basename in ec++*) lt_prog_compiler_pic_CXX='-KPIC' ;; ghcx*) # Green Hills C++ Compiler lt_prog_compiler_pic_CXX='-pic' ;; *) ;; esac ;; freebsd* | dragonfly*) # FreeBSD uses GNU C++ ;; hpux9* | hpux10* | hpux11*) case $cc_basename in CC*) lt_prog_compiler_wl_CXX='-Wl,' lt_prog_compiler_static_CXX='${wl}-a ${wl}archive' if test "$host_cpu" != ia64; then lt_prog_compiler_pic_CXX='+Z' fi ;; aCC*) lt_prog_compiler_wl_CXX='-Wl,' lt_prog_compiler_static_CXX='${wl}-a ${wl}archive' case $host_cpu in hppa*64*|ia64*) # +Z the default ;; *) lt_prog_compiler_pic_CXX='+Z' ;; esac ;; *) ;; esac ;; interix*) # This is c89, which is MS Visual C++ (no shared libs) # Anyone wants to do a port? ;; irix5* | irix6* | nonstopux*) case $cc_basename in CC*) lt_prog_compiler_wl_CXX='-Wl,' lt_prog_compiler_static_CXX='-non_shared' # CC pic flag -KPIC is the default. ;; *) ;; esac ;; linux* | k*bsd*-gnu | kopensolaris*-gnu) case $cc_basename in KCC*) # KAI C++ Compiler lt_prog_compiler_wl_CXX='--backend -Wl,' lt_prog_compiler_pic_CXX='-fPIC' ;; ecpc* ) # old Intel C++ for x86_64 which still supported -KPIC. lt_prog_compiler_wl_CXX='-Wl,' lt_prog_compiler_pic_CXX='-KPIC' lt_prog_compiler_static_CXX='-static' ;; icpc* ) # Intel C++, used to be incompatible with GCC. # ICC 10 doesn't accept -KPIC any more. lt_prog_compiler_wl_CXX='-Wl,' lt_prog_compiler_pic_CXX='-fPIC' lt_prog_compiler_static_CXX='-static' ;; pgCC* | pgcpp*) # Portland Group C++ compiler lt_prog_compiler_wl_CXX='-Wl,' lt_prog_compiler_pic_CXX='-fpic' lt_prog_compiler_static_CXX='-Bstatic' ;; cxx*) # Compaq C++ # Make sure the PIC flag is empty. It appears that all Alpha # Linux and Compaq Tru64 Unix objects are PIC. lt_prog_compiler_pic_CXX= lt_prog_compiler_static_CXX='-non_shared' ;; xlc* | xlC* | bgxl[cC]* | mpixl[cC]*) # IBM XL 8.0, 9.0 on PPC and BlueGene lt_prog_compiler_wl_CXX='-Wl,' lt_prog_compiler_pic_CXX='-qpic' lt_prog_compiler_static_CXX='-qstaticlink' ;; *) case `$CC -V 2>&1 | sed 5q` in *Sun\ C*) # Sun C++ 5.9 lt_prog_compiler_pic_CXX='-KPIC' lt_prog_compiler_static_CXX='-Bstatic' lt_prog_compiler_wl_CXX='-Qoption ld ' ;; esac ;; esac ;; lynxos*) ;; m88k*) ;; mvs*) case $cc_basename in cxx*) lt_prog_compiler_pic_CXX='-W c,exportall' ;; *) ;; esac ;; netbsd*) ;; *qnx* | *nto*) # QNX uses GNU C++, but need to define -shared option too, otherwise # it will coredump. lt_prog_compiler_pic_CXX='-fPIC -shared' ;; osf3* | osf4* | osf5*) case $cc_basename in KCC*) lt_prog_compiler_wl_CXX='--backend -Wl,' ;; RCC*) # Rational C++ 2.4.1 lt_prog_compiler_pic_CXX='-pic' ;; cxx*) # Digital/Compaq C++ lt_prog_compiler_wl_CXX='-Wl,' # Make sure the PIC flag is empty. It appears that all Alpha # Linux and Compaq Tru64 Unix objects are PIC. lt_prog_compiler_pic_CXX= lt_prog_compiler_static_CXX='-non_shared' ;; *) ;; esac ;; psos*) ;; solaris*) case $cc_basename in CC* | sunCC*) # Sun C++ 4.2, 5.x and Centerline C++ lt_prog_compiler_pic_CXX='-KPIC' lt_prog_compiler_static_CXX='-Bstatic' lt_prog_compiler_wl_CXX='-Qoption ld ' ;; gcx*) # Green Hills C++ Compiler lt_prog_compiler_pic_CXX='-PIC' ;; *) ;; esac ;; sunos4*) case $cc_basename in CC*) # Sun C++ 4.x lt_prog_compiler_pic_CXX='-pic' lt_prog_compiler_static_CXX='-Bstatic' ;; lcc*) # Lucid lt_prog_compiler_pic_CXX='-pic' ;; *) ;; esac ;; sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*) case $cc_basename in CC*) lt_prog_compiler_wl_CXX='-Wl,' lt_prog_compiler_pic_CXX='-KPIC' lt_prog_compiler_static_CXX='-Bstatic' ;; esac ;; tandem*) case $cc_basename in NCC*) # NonStop-UX NCC 3.20 lt_prog_compiler_pic_CXX='-KPIC' ;; *) ;; esac ;; vxworks*) ;; *) lt_prog_compiler_can_build_shared_CXX=no ;; esac fi case $host_os in # For platforms which do not support PIC, -DPIC is meaningless: *djgpp*) lt_prog_compiler_pic_CXX= ;; *) lt_prog_compiler_pic_CXX="$lt_prog_compiler_pic_CXX -DPIC" ;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5 $as_echo_n "checking for $compiler option to produce PIC... " >&6; } if ${lt_cv_prog_compiler_pic_CXX+:} false; then : $as_echo_n "(cached) " >&6 else lt_cv_prog_compiler_pic_CXX=$lt_prog_compiler_pic_CXX fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_CXX" >&5 $as_echo "$lt_cv_prog_compiler_pic_CXX" >&6; } lt_prog_compiler_pic_CXX=$lt_cv_prog_compiler_pic_CXX # # Check to make sure the PIC flag actually works. # if test -n "$lt_prog_compiler_pic_CXX"; then { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works" >&5 $as_echo_n "checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works... " >&6; } if ${lt_cv_prog_compiler_pic_works_CXX+:} false; then : $as_echo_n "(cached) " >&6 else lt_cv_prog_compiler_pic_works_CXX=no ac_outfile=conftest.$ac_objext echo "$lt_simple_compile_test_code" > conftest.$ac_ext lt_compiler_flag="$lt_prog_compiler_pic_CXX -DPIC" # Insert the option either (1) after the last *FLAGS variable, or # (2) before a word containing "conftest.", or (3) at the end. # Note that $ac_compile itself does not contain backslashes and begins # with a dollar sign (not a hyphen), so the echo should work correctly. # The option is referenced via a variable to avoid confusing sed. lt_compile=`echo "$ac_compile" | $SED \ -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ -e 's:$: $lt_compiler_flag:'` (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5) (eval "$lt_compile" 2>conftest.err) ac_status=$? cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 if (exit $ac_status) && test -s "$ac_outfile"; then # The compiler can only warn and ignore the option if not recognized # So say no if there are warnings other than the usual output. $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then lt_cv_prog_compiler_pic_works_CXX=yes fi fi $RM conftest* fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works_CXX" >&5 $as_echo "$lt_cv_prog_compiler_pic_works_CXX" >&6; } if test x"$lt_cv_prog_compiler_pic_works_CXX" = xyes; then case $lt_prog_compiler_pic_CXX in "" | " "*) ;; *) lt_prog_compiler_pic_CXX=" $lt_prog_compiler_pic_CXX" ;; esac else lt_prog_compiler_pic_CXX= lt_prog_compiler_can_build_shared_CXX=no fi fi # # Check to make sure the static flag actually works. # wl=$lt_prog_compiler_wl_CXX eval lt_tmp_static_flag=\"$lt_prog_compiler_static_CXX\" { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5 $as_echo_n "checking if $compiler static flag $lt_tmp_static_flag works... " >&6; } if ${lt_cv_prog_compiler_static_works_CXX+:} false; then : $as_echo_n "(cached) " >&6 else lt_cv_prog_compiler_static_works_CXX=no save_LDFLAGS="$LDFLAGS" LDFLAGS="$LDFLAGS $lt_tmp_static_flag" echo "$lt_simple_link_test_code" > conftest.$ac_ext if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then # The linker can only warn and ignore the option if not recognized # So say no if there are warnings if test -s conftest.err; then # Append any errors to the config.log. cat conftest.err 1>&5 $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 if diff conftest.exp conftest.er2 >/dev/null; then lt_cv_prog_compiler_static_works_CXX=yes fi else lt_cv_prog_compiler_static_works_CXX=yes fi fi $RM -r conftest* LDFLAGS="$save_LDFLAGS" fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works_CXX" >&5 $as_echo "$lt_cv_prog_compiler_static_works_CXX" >&6; } if test x"$lt_cv_prog_compiler_static_works_CXX" = xyes; then : else lt_prog_compiler_static_CXX= fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 $as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; } if ${lt_cv_prog_compiler_c_o_CXX+:} false; then : $as_echo_n "(cached) " >&6 else lt_cv_prog_compiler_c_o_CXX=no $RM -r conftest 2>/dev/null mkdir conftest cd conftest mkdir out echo "$lt_simple_compile_test_code" > conftest.$ac_ext lt_compiler_flag="-o out/conftest2.$ac_objext" # Insert the option either (1) after the last *FLAGS variable, or # (2) before a word containing "conftest.", or (3) at the end. # Note that $ac_compile itself does not contain backslashes and begins # with a dollar sign (not a hyphen), so the echo should work correctly. lt_compile=`echo "$ac_compile" | $SED \ -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ -e 's:$: $lt_compiler_flag:'` (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5) (eval "$lt_compile" 2>out/conftest.err) ac_status=$? cat out/conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 if (exit $ac_status) && test -s out/conftest2.$ac_objext then # The compiler can only warn and ignore the option if not recognized # So say no if there are warnings $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2 if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then lt_cv_prog_compiler_c_o_CXX=yes fi fi chmod u+w . 2>&5 $RM conftest* # SGI C++ compiler will create directory out/ii_files/ for # template instantiation test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files $RM out/* && rmdir out cd .. $RM -r conftest $RM conftest* fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_CXX" >&5 $as_echo "$lt_cv_prog_compiler_c_o_CXX" >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 $as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; } if ${lt_cv_prog_compiler_c_o_CXX+:} false; then : $as_echo_n "(cached) " >&6 else lt_cv_prog_compiler_c_o_CXX=no $RM -r conftest 2>/dev/null mkdir conftest cd conftest mkdir out echo "$lt_simple_compile_test_code" > conftest.$ac_ext lt_compiler_flag="-o out/conftest2.$ac_objext" # Insert the option either (1) after the last *FLAGS variable, or # (2) before a word containing "conftest.", or (3) at the end. # Note that $ac_compile itself does not contain backslashes and begins # with a dollar sign (not a hyphen), so the echo should work correctly. lt_compile=`echo "$ac_compile" | $SED \ -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ -e 's:$: $lt_compiler_flag:'` (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5) (eval "$lt_compile" 2>out/conftest.err) ac_status=$? cat out/conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 if (exit $ac_status) && test -s out/conftest2.$ac_objext then # The compiler can only warn and ignore the option if not recognized # So say no if there are warnings $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2 if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then lt_cv_prog_compiler_c_o_CXX=yes fi fi chmod u+w . 2>&5 $RM conftest* # SGI C++ compiler will create directory out/ii_files/ for # template instantiation test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files $RM out/* && rmdir out cd .. $RM -r conftest $RM conftest* fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_CXX" >&5 $as_echo "$lt_cv_prog_compiler_c_o_CXX" >&6; } hard_links="nottested" if test "$lt_cv_prog_compiler_c_o_CXX" = no && test "$need_locks" != no; then # do not overwrite the value of need_locks provided by the user { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5 $as_echo_n "checking if we can lock with hard links... " >&6; } hard_links=yes $RM conftest* ln conftest.a conftest.b 2>/dev/null && hard_links=no touch conftest.a ln conftest.a conftest.b 2>&5 || hard_links=no ln conftest.a conftest.b 2>/dev/null && hard_links=no { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5 $as_echo "$hard_links" >&6; } if test "$hard_links" = no; then { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5 $as_echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;} need_locks=warn fi else need_locks=no fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 $as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; } export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' exclude_expsyms_CXX='_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*' case $host_os in aix[4-9]*) # If we're using GNU nm, then we don't want the "-C" option. # -C means demangle to AIX nm, but means don't demangle with GNU nm # Also, AIX nm treats weak defined symbols like other global defined # symbols, whereas GNU nm marks them as "W". if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then export_symbols_cmds_CXX='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' else export_symbols_cmds_CXX='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' fi ;; pw32*) export_symbols_cmds_CXX="$ltdll_cmds" ;; cygwin* | mingw* | cegcc*) case $cc_basename in cl*) ;; *) export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1 DATA/;s/^.*[ ]__nm__\([^ ]*\)[ ][^ ]*/\1 DATA/;/^I[ ]/d;/^[AITW][ ]/s/.* //'\'' | sort | uniq > $export_symbols' exclude_expsyms_CXX='[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname' ;; esac ;; *) export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' ;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5 $as_echo "$ld_shlibs_CXX" >&6; } test "$ld_shlibs_CXX" = no && can_build_shared=no with_gnu_ld_CXX=$with_gnu_ld # # Do we need to explicitly link libc? # case "x$archive_cmds_need_lc_CXX" in x|xyes) # Assume -lc should be added archive_cmds_need_lc_CXX=yes if test "$enable_shared" = yes && test "$GCC" = yes; then case $archive_cmds_CXX in *'~'*) # FIXME: we may have to deal with multi-command sequences. ;; '$CC '*) # Test whether the compiler implicitly links with -lc since on some # systems, -lgcc has to come before -lc. If gcc already passes -lc # to ld, don't add -lc before -lgcc. { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5 $as_echo_n "checking whether -lc should be explicitly linked in... " >&6; } if ${lt_cv_archive_cmds_need_lc_CXX+:} false; then : $as_echo_n "(cached) " >&6 else $RM conftest* echo "$lt_simple_compile_test_code" > conftest.$ac_ext if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 (eval $ac_compile) 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } 2>conftest.err; then soname=conftest lib=conftest libobjs=conftest.$ac_objext deplibs= wl=$lt_prog_compiler_wl_CXX pic_flag=$lt_prog_compiler_pic_CXX compiler_flags=-v linker_flags=-v verstring= output_objdir=. libname=conftest lt_save_allow_undefined_flag=$allow_undefined_flag_CXX allow_undefined_flag_CXX= if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds_CXX 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1\""; } >&5 (eval $archive_cmds_CXX 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } then lt_cv_archive_cmds_need_lc_CXX=no else lt_cv_archive_cmds_need_lc_CXX=yes fi allow_undefined_flag_CXX=$lt_save_allow_undefined_flag else cat conftest.err 1>&5 fi $RM conftest* fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc_CXX" >&5 $as_echo "$lt_cv_archive_cmds_need_lc_CXX" >&6; } archive_cmds_need_lc_CXX=$lt_cv_archive_cmds_need_lc_CXX ;; esac fi ;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5 $as_echo_n "checking dynamic linker characteristics... " >&6; } library_names_spec= libname_spec='lib$name' soname_spec= shrext_cmds=".so" postinstall_cmds= postuninstall_cmds= finish_cmds= finish_eval= shlibpath_var= shlibpath_overrides_runpath=unknown version_type=none dynamic_linker="$host_os ld.so" sys_lib_dlsearch_path_spec="/lib /usr/lib" need_lib_prefix=unknown hardcode_into_libs=no # when you set need_version to no, make sure it does not cause -set_version # flags to be left without arguments need_version=unknown case $host_os in aix3*) version_type=linux library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a' shlibpath_var=LIBPATH # AIX 3 has no versioning support, so we append a major version to the name. soname_spec='${libname}${release}${shared_ext}$major' ;; aix[4-9]*) version_type=linux need_lib_prefix=no need_version=no hardcode_into_libs=yes if test "$host_cpu" = ia64; then # AIX 5 supports IA64 library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}' shlibpath_var=LD_LIBRARY_PATH else # With GCC up to 2.95.x, collect2 would create an import file # for dependence libraries. The import file would start with # the line `#! .'. This would cause the generated library to # depend on `.', always an invalid library. This was fixed in # development snapshots of GCC prior to 3.0. case $host_os in aix4 | aix4.[01] | aix4.[01].*) if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)' echo ' yes ' echo '#endif'; } | ${CC} -E - | $GREP yes > /dev/null; then : else can_build_shared=no fi ;; esac # AIX (on Power*) has no versioning support, so currently we can not hardcode correct # soname into executable. Probably we can add versioning support to # collect2, so additional links can be useful in future. if test "$aix_use_runtimelinking" = yes; then # If using run time linking (on AIX 4.2 or later) use lib.so # instead of lib.a to let people know that these are not # typical AIX shared libraries. library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' else # We preserve .a as extension for shared libraries through AIX4.2 # and later when we are not doing run time linking. library_names_spec='${libname}${release}.a $libname.a' soname_spec='${libname}${release}${shared_ext}$major' fi shlibpath_var=LIBPATH fi ;; amigaos*) case $host_cpu in powerpc) # Since July 2007 AmigaOS4 officially supports .so libraries. # When compiling the executable, add -use-dynld -Lsobjs: to the compileline. library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' ;; m68k) library_names_spec='$libname.ixlibrary $libname.a' # Create ${libname}_ixlibrary.a entries in /sys/libs. finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done' ;; esac ;; beos*) library_names_spec='${libname}${shared_ext}' dynamic_linker="$host_os ld.so" shlibpath_var=LIBRARY_PATH ;; bsdi[45]*) version_type=linux need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir' shlibpath_var=LD_LIBRARY_PATH sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib" sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib" # the default ld.so.conf also contains /usr/contrib/lib and # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow # libtool to hard-code these into programs ;; cygwin* | mingw* | pw32* | cegcc*) version_type=windows shrext_cmds=".dll" need_version=no need_lib_prefix=no case $GCC,$cc_basename in yes,*) # gcc library_names_spec='$libname.dll.a' # DLL is installed to $(libdir)/../bin by postinstall_cmds postinstall_cmds='base_file=`basename \${file}`~ dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~ dldir=$destdir/`dirname \$dlpath`~ test -d \$dldir || mkdir -p \$dldir~ $install_prog $dir/$dlname \$dldir/$dlname~ chmod a+x \$dldir/$dlname~ if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then eval '\''$striplib \$dldir/$dlname'\'' || exit \$?; fi' postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ dlpath=$dir/\$dldll~ $RM \$dlpath' shlibpath_overrides_runpath=yes case $host_os in cygwin*) # Cygwin DLLs use 'cyg' prefix rather than 'lib' soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' ;; mingw* | cegcc*) # MinGW DLLs use traditional 'lib' prefix soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' ;; pw32*) # pw32 DLLs use 'pw' prefix rather than 'lib' library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' ;; esac dynamic_linker='Win32 ld.exe' ;; *,cl*) # Native MSVC libname_spec='$name' soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' library_names_spec='${libname}.dll.lib' case $build_os in mingw*) sys_lib_search_path_spec= lt_save_ifs=$IFS IFS=';' for lt_path in $LIB do IFS=$lt_save_ifs # Let DOS variable expansion print the short 8.3 style file name. lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"` sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path" done IFS=$lt_save_ifs # Convert to MSYS style. sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([a-zA-Z]\\):| /\\1|g' -e 's|^ ||'` ;; cygwin*) # Convert to unix form, then to dos form, then back to unix form # but this time dos style (no spaces!) so that the unix form looks # like /cygdrive/c/PROGRA~1:/cygdr... sys_lib_search_path_spec=`cygpath --path --unix "$LIB"` sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null` sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` ;; *) sys_lib_search_path_spec="$LIB" if $ECHO "$sys_lib_search_path_spec" | $GREP ';[c-zC-Z]:/' >/dev/null; then # It is most probably a Windows format PATH. sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` else sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` fi # FIXME: find the short name or the path components, as spaces are # common. (e.g. "Program Files" -> "PROGRA~1") ;; esac # DLL is installed to $(libdir)/../bin by postinstall_cmds postinstall_cmds='base_file=`basename \${file}`~ dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~ dldir=$destdir/`dirname \$dlpath`~ test -d \$dldir || mkdir -p \$dldir~ $install_prog $dir/$dlname \$dldir/$dlname' postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ dlpath=$dir/\$dldll~ $RM \$dlpath' shlibpath_overrides_runpath=yes dynamic_linker='Win32 link.exe' ;; *) # Assume MSVC wrapper library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib' dynamic_linker='Win32 ld.exe' ;; esac # FIXME: first we should search . and the directory the executable is in shlibpath_var=PATH ;; darwin* | rhapsody*) dynamic_linker="$host_os dyld" version_type=darwin need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${major}$shared_ext ${libname}$shared_ext' soname_spec='${libname}${release}${major}$shared_ext' shlibpath_overrides_runpath=yes shlibpath_var=DYLD_LIBRARY_PATH shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`' sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib' ;; dgux*) version_type=linux need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LD_LIBRARY_PATH ;; freebsd1*) dynamic_linker=no ;; freebsd* | dragonfly*) # DragonFly does not have aout. When/if they implement a new # versioning mechanism, adjust this. if test -x /usr/bin/objformat; then objformat=`/usr/bin/objformat` else case $host_os in freebsd[123]*) objformat=aout ;; *) objformat=elf ;; esac fi version_type=freebsd-$objformat case $version_type in freebsd-elf*) library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' need_version=no need_lib_prefix=no ;; freebsd-*) library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix' need_version=yes ;; esac shlibpath_var=LD_LIBRARY_PATH case $host_os in freebsd2*) shlibpath_overrides_runpath=yes ;; freebsd3.[01]* | freebsdelf3.[01]*) shlibpath_overrides_runpath=yes hardcode_into_libs=yes ;; freebsd3.[2-9]* | freebsdelf3.[2-9]* | \ freebsd4.[0-5] | freebsdelf4.[0-5] | freebsd4.1.1 | freebsdelf4.1.1) shlibpath_overrides_runpath=no hardcode_into_libs=yes ;; *) # from 4.6 on, and DragonFly shlibpath_overrides_runpath=yes hardcode_into_libs=yes ;; esac ;; gnu*) version_type=linux need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LD_LIBRARY_PATH hardcode_into_libs=yes ;; haiku*) version_type=linux need_lib_prefix=no need_version=no dynamic_linker="$host_os runtime_loader" library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LIBRARY_PATH shlibpath_overrides_runpath=yes sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib' hardcode_into_libs=yes ;; hpux9* | hpux10* | hpux11*) # Give a soname corresponding to the major version so that dld.sl refuses to # link against other versions. version_type=sunos need_lib_prefix=no need_version=no case $host_cpu in ia64*) shrext_cmds='.so' hardcode_into_libs=yes dynamic_linker="$host_os dld.so" shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' if test "X$HPUX_IA64_MODE" = X32; then sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" else sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" fi sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec ;; hppa*64*) shrext_cmds='.sl' hardcode_into_libs=yes dynamic_linker="$host_os dld.sl" shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64" sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec ;; *) shrext_cmds='.sl' dynamic_linker="$host_os dld.sl" shlibpath_var=SHLIB_PATH shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' ;; esac # HP-UX runs *really* slowly unless shared libraries are mode 555, ... postinstall_cmds='chmod 555 $lib' # or fails outright, so override atomically: install_override_mode=555 ;; interix[3-9]*) version_type=linux need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=no hardcode_into_libs=yes ;; irix5* | irix6* | nonstopux*) case $host_os in nonstopux*) version_type=nonstopux ;; *) if test "$lt_cv_prog_gnu_ld" = yes; then version_type=linux else version_type=irix fi ;; esac need_lib_prefix=no need_version=no soname_spec='${libname}${release}${shared_ext}$major' library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}' case $host_os in irix5* | nonstopux*) libsuff= shlibsuff= ;; *) case $LD in # libtool.m4 will add one of these switches to LD *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ") libsuff= shlibsuff= libmagic=32-bit;; *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ") libsuff=32 shlibsuff=N32 libmagic=N32;; *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ") libsuff=64 shlibsuff=64 libmagic=64-bit;; *) libsuff= shlibsuff= libmagic=never-match;; esac ;; esac shlibpath_var=LD_LIBRARY${shlibsuff}_PATH shlibpath_overrides_runpath=no sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}" sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}" hardcode_into_libs=yes ;; # No shared lib support for Linux oldld, aout, or coff. linux*oldld* | linux*aout* | linux*coff*) dynamic_linker=no ;; # This must be Linux ELF. linux* | k*bsd*-gnu | kopensolaris*-gnu) version_type=linux need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=no # Some binutils ld are patched to set DT_RUNPATH if ${lt_cv_shlibpath_overrides_runpath+:} false; then : $as_echo_n "(cached) " >&6 else lt_cv_shlibpath_overrides_runpath=no save_LDFLAGS=$LDFLAGS save_libdir=$libdir eval "libdir=/foo; wl=\"$lt_prog_compiler_wl_CXX\"; \ LDFLAGS=\"\$LDFLAGS $hardcode_libdir_flag_spec_CXX\"" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_cxx_try_link "$LINENO"; then : if ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null; then : lt_cv_shlibpath_overrides_runpath=yes fi fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LDFLAGS=$save_LDFLAGS libdir=$save_libdir fi shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath # This implies no fast_install, which is unacceptable. # Some rework will be needed to allow for fast_install # before this can be enabled. hardcode_into_libs=yes # Add ABI-specific directories to the system library path. sys_lib_dlsearch_path_spec="/lib64 /usr/lib64 /lib /usr/lib" # Append ld.so.conf contents to the search path if test -f /etc/ld.so.conf; then lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[ ]*hwcap[ ]/d;s/[:, ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '` sys_lib_dlsearch_path_spec="$sys_lib_dlsearch_path_spec $lt_ld_extra" fi # We used to test for /lib/ld.so.1 and disable shared libraries on # powerpc, because MkLinux only supported shared libraries with the # GNU dynamic linker. Since this was broken with cross compilers, # most powerpc-linux boxes support dynamic linking these days and # people can always --disable-shared, the test was removed, and we # assume the GNU/Linux dynamic linker is in use. dynamic_linker='GNU/Linux ld.so' ;; netbsd*) version_type=sunos need_lib_prefix=no need_version=no if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' dynamic_linker='NetBSD (a.out) ld.so' else library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' dynamic_linker='NetBSD ld.elf_so' fi shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes hardcode_into_libs=yes ;; newsos6) version_type=linux library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes ;; *nto* | *qnx*) version_type=qnx need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=no hardcode_into_libs=yes dynamic_linker='ldqnx.so' ;; openbsd*) version_type=sunos sys_lib_dlsearch_path_spec="/usr/lib" need_lib_prefix=no # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs. case $host_os in openbsd3.3 | openbsd3.3.*) need_version=yes ;; *) need_version=no ;; esac library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' shlibpath_var=LD_LIBRARY_PATH if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then case $host_os in openbsd2.[89] | openbsd2.[89].*) shlibpath_overrides_runpath=no ;; *) shlibpath_overrides_runpath=yes ;; esac else shlibpath_overrides_runpath=yes fi ;; os2*) libname_spec='$name' shrext_cmds=".dll" need_lib_prefix=no library_names_spec='$libname${shared_ext} $libname.a' dynamic_linker='OS/2 ld.exe' shlibpath_var=LIBPATH ;; osf3* | osf4* | osf5*) version_type=osf need_lib_prefix=no need_version=no soname_spec='${libname}${release}${shared_ext}$major' library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' shlibpath_var=LD_LIBRARY_PATH sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib" sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec" ;; rdos*) dynamic_linker=no ;; solaris*) version_type=linux need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes hardcode_into_libs=yes # ldd complains unless libraries are executable postinstall_cmds='chmod +x $lib' ;; sunos4*) version_type=sunos library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes if test "$with_gnu_ld" = yes; then need_lib_prefix=no fi need_version=yes ;; sysv4 | sysv4.3*) version_type=linux library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LD_LIBRARY_PATH case $host_vendor in sni) shlibpath_overrides_runpath=no need_lib_prefix=no runpath_var=LD_RUN_PATH ;; siemens) need_lib_prefix=no ;; motorola) need_lib_prefix=no need_version=no shlibpath_overrides_runpath=no sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib' ;; esac ;; sysv4*MP*) if test -d /usr/nec ;then version_type=linux library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}' soname_spec='$libname${shared_ext}.$major' shlibpath_var=LD_LIBRARY_PATH fi ;; sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*) version_type=freebsd-elf need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes hardcode_into_libs=yes if test "$with_gnu_ld" = yes; then sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib' else sys_lib_search_path_spec='/usr/ccs/lib /usr/lib' case $host_os in sco3.2v5*) sys_lib_search_path_spec="$sys_lib_search_path_spec /lib" ;; esac fi sys_lib_dlsearch_path_spec='/usr/lib' ;; tpf*) # TPF is a cross-target only. Preferred cross-host = GNU/Linux. version_type=linux need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=no hardcode_into_libs=yes ;; uts4*) version_type=linux library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LD_LIBRARY_PATH ;; *) dynamic_linker=no ;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5 $as_echo "$dynamic_linker" >&6; } test "$dynamic_linker" = no && can_build_shared=no variables_saved_for_relink="PATH $shlibpath_var $runpath_var" if test "$GCC" = yes; then variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" fi if test "${lt_cv_sys_lib_search_path_spec+set}" = set; then sys_lib_search_path_spec="$lt_cv_sys_lib_search_path_spec" fi if test "${lt_cv_sys_lib_dlsearch_path_spec+set}" = set; then sys_lib_dlsearch_path_spec="$lt_cv_sys_lib_dlsearch_path_spec" fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5 $as_echo_n "checking how to hardcode library paths into programs... " >&6; } hardcode_action_CXX= if test -n "$hardcode_libdir_flag_spec_CXX" || test -n "$runpath_var_CXX" || test "X$hardcode_automatic_CXX" = "Xyes" ; then # We can hardcode non-existent directories. if test "$hardcode_direct_CXX" != no && # If the only mechanism to avoid hardcoding is shlibpath_var, we # have to relink, otherwise we might link with an installed library # when we should be linking with a yet-to-be-installed one ## test "$_LT_TAGVAR(hardcode_shlibpath_var, CXX)" != no && test "$hardcode_minus_L_CXX" != no; then # Linking always hardcodes the temporary library directory. hardcode_action_CXX=relink else # We can link without hardcoding, and we can hardcode nonexisting dirs. hardcode_action_CXX=immediate fi else # We cannot hardcode anything, or else we can only hardcode existing # directories. hardcode_action_CXX=unsupported fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hardcode_action_CXX" >&5 $as_echo "$hardcode_action_CXX" >&6; } if test "$hardcode_action_CXX" = relink || test "$inherit_rpath_CXX" = yes; then # Fast installation is not supported enable_fast_install=no elif test "$shlibpath_overrides_runpath" = yes || test "$enable_shared" = no; then # Fast installation is not necessary enable_fast_install=needless fi fi # test -n "$compiler" CC=$lt_save_CC CFLAGS=$lt_save_CFLAGS LDCXX=$LD LD=$lt_save_LD GCC=$lt_save_GCC with_gnu_ld=$lt_save_with_gnu_ld lt_cv_path_LDCXX=$lt_cv_path_LD lt_cv_path_LD=$lt_save_path_LD lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld fi # test "$_lt_caught_CXX_error" != yes ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu # AC_PROG_CXX doesn't fail if compiler is not found, test it explicitely ac_ext=cpp ac_cpp='$CXXCPP $CPPFLAGS' ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_cxx_compiler_gnu cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_cxx_try_link "$LINENO"; then : else as_fn_error $? "C++ compiler not found." "$LINENO" 5 fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable maintainer-specific portions of Makefiles" >&5 $as_echo_n "checking whether to enable maintainer-specific portions of Makefiles... " >&6; } # Check whether --enable-maintainer-mode was given. if test "${enable_maintainer_mode+set}" = set; then : enableval=$enable_maintainer_mode; USE_MAINTAINER_MODE=$enableval else USE_MAINTAINER_MODE=no fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $USE_MAINTAINER_MODE" >&5 $as_echo "$USE_MAINTAINER_MODE" >&6; } if test $USE_MAINTAINER_MODE = yes; then MAINTAINER_MODE_TRUE= MAINTAINER_MODE_FALSE='#' else MAINTAINER_MODE_TRUE='#' MAINTAINER_MODE_FALSE= fi MAINT=$MAINTAINER_MODE_TRUE { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing cos" >&5 $as_echo_n "checking for library containing cos... " >&6; } if ${ac_cv_search_cos+:} false; then : $as_echo_n "(cached) " >&6 else ac_func_search_save_LIBS=$LIBS cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ #ifdef __cplusplus extern "C" #endif char cos (); int main () { return cos (); ; return 0; } _ACEOF for ac_lib in '' m; do if test -z "$ac_lib"; then ac_res="none required" else ac_res=-l$ac_lib LIBS="-l$ac_lib $ac_func_search_save_LIBS" fi if ac_fn_c_try_link "$LINENO"; then : ac_cv_search_cos=$ac_res fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext if ${ac_cv_search_cos+:} false; then : break fi done if ${ac_cv_search_cos+:} false; then : else ac_cv_search_cos=no fi rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_cos" >&5 $as_echo "$ac_cv_search_cos" >&6; } ac_res=$ac_cv_search_cos if test "$ac_res" != no; then : test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" else as_fn_error $? "need math library" "$LINENO" 5 fi ac_config_files="$ac_config_files Makefile mmdb.pc" cat >confcache <<\_ACEOF # 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, see configure's option --config-cache. # It is not useful on other systems. If it contains results you don't # want to keep, you may remove or edit it. # # config.status only pays attention to the cache file if you give it # the --recheck option to rerun configure. # # `ac_cv_env_foo' variables (set or unset) will be overridden when # loading this file, other *unset* `ac_cv_foo' will be assigned the # following values. _ACEOF # The following way of writing the cache mishandles newlines in values, # but we know of no workaround that is simple, portable, and efficient. # So, we kill variables containing newlines. # 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. ( for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do eval ac_val=\$$ac_var case $ac_val in #( *${as_nl}*) case $ac_var in #( *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( *) { eval $ac_var=; unset $ac_var;} ;; esac ;; esac done (set) 2>&1 | case $as_nl`(ac_space=' '; set) 2>&1` in #( *${as_nl}ac_space=\ *) # `set' does not quote correctly, so add quotes: double-quote # substitution turns \\\\ into \\, and sed turns \\ into \. sed -n \ "s/'/'\\\\''/g; s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" ;; #( *) # `set' quotes correctly as required by POSIX, so do not add quotes. sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" ;; esac | sort ) | sed ' /^ac_cv_env_/b end t clear :clear s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ t end s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ :end' >>confcache if diff "$cache_file" confcache >/dev/null 2>&1; then :; else if test -w "$cache_file"; then if test "x$cache_file" != "x/dev/null"; then { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 $as_echo "$as_me: updating cache $cache_file" >&6;} if test ! -f "$cache_file" || test -h "$cache_file"; then cat confcache >"$cache_file" else case $cache_file in #( */* | ?:*) mv -f confcache "$cache_file"$$ && mv -f "$cache_file"$$ "$cache_file" ;; #( *) mv -f confcache "$cache_file" ;; esac fi fi else { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 $as_echo "$as_me: not updating unwritable cache $cache_file" >&6;} fi fi rm -f confcache test "x$prefix" = xNONE && prefix=$ac_default_prefix # Let make expand exec_prefix. test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' DEFS=-DHAVE_CONFIG_H ac_libobjs= ac_ltlibobjs= U= for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue # 1. Remove the extension, and $U if already installed. ac_script='s/\$U\././;s/\.o$//;s/\.obj$//' ac_i=`$as_echo "$ac_i" | sed "$ac_script"` # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR # will be set to the directory where LIBOBJS objects are built. as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext" as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo' done LIBOBJS=$ac_libobjs LTLIBOBJS=$ac_ltlibobjs { $as_echo "$as_me:${as_lineno-$LINENO}: checking that generated files are newer than configure" >&5 $as_echo_n "checking that generated files are newer than configure... " >&6; } if test -n "$am_sleep_pid"; then # Hide warnings about reused PIDs. wait $am_sleep_pid 2>/dev/null fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: done" >&5 $as_echo "done" >&6; } if test -n "$EXEEXT"; then am__EXEEXT_TRUE= am__EXEEXT_FALSE='#' else am__EXEEXT_TRUE='#' am__EXEEXT_FALSE= fi if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then as_fn_error $? "conditional \"AMDEP\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then as_fn_error $? "conditional \"am__fastdepCC\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${am__fastdepCXX_TRUE}" && test -z "${am__fastdepCXX_FALSE}"; then as_fn_error $? "conditional \"am__fastdepCXX\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${MAINTAINER_MODE_TRUE}" && test -z "${MAINTAINER_MODE_FALSE}"; then as_fn_error $? "conditional \"MAINTAINER_MODE\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi : "${CONFIG_STATUS=./config.status}" ac_write_fail=0 ac_clean_files_save=$ac_clean_files ac_clean_files="$ac_clean_files $CONFIG_STATUS" { $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5 $as_echo "$as_me: creating $CONFIG_STATUS" >&6;} as_write_fail=0 cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1 #! $SHELL # Generated by $as_me. # Run this file to recreate the current configuration. # Compiler output produced by configure, useful for debugging # configure, is in config.log if it exists. debug=false ac_cs_recheck=false ac_cs_silent=false SHELL=\${CONFIG_SHELL-$SHELL} export SHELL _ASEOF cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1 ## -------------------- ## ## M4sh Initialization. ## ## -------------------- ## # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else case `(set -o) 2>/dev/null` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi as_nl=' ' export as_nl # Printing a long string crashes Solaris 7 /usr/bin/printf. as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo # Prefer a ksh shell builtin over an external printf program on Solaris, # but without wasting forks for bash or zsh. if test -z "$BASH_VERSION$ZSH_VERSION" \ && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='print -r --' as_echo_n='print -rn --' elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='printf %s\n' as_echo_n='printf %s' else if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' as_echo_n='/usr/ucb/echo -n' else as_echo_body='eval expr "X$1" : "X\\(.*\\)"' as_echo_n_body='eval arg=$1; case $arg in #( *"$as_nl"*) expr "X$arg" : "X\\(.*\\)$as_nl"; arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; esac; expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" ' export as_echo_n_body as_echo_n='sh -c $as_echo_n_body as_echo' fi export as_echo_body as_echo='sh -c $as_echo_body as_echo' fi # The user is always right. if test "${PATH_SEPARATOR+set}" != set; then PATH_SEPARATOR=: (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || PATH_SEPARATOR=';' } fi # IFS # We need space, tab and new line, in precisely that order. Quoting is # there to prevent editors from complaining about space-tab. # (If _AS_PATH_WALK were called with IFS unset, it would disable word # splitting by setting IFS to empty value.) IFS=" "" $as_nl" # Find who we are. Look in the path if we contain no directory separator. as_myself= case $0 in #(( *[\\/]* ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break done IFS=$as_save_IFS ;; esac # We did not find ourselves, most probably we were run as `sh COMMAND' # in which case we are not to be found in the path. if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 exit 1 fi # Unset variables that we do not need and which cause bugs (e.g. in # pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" # suppresses any "Segmentation fault" message there. '((' could # trigger a bug in pdksh 5.2.14. for as_var in BASH_ENV ENV MAIL MAILPATH do eval test x\${$as_var+set} = xset \ && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : done PS1='$ ' PS2='> ' PS4='+ ' # NLS nuisances. LC_ALL=C export LC_ALL LANGUAGE=C export LANGUAGE # CDPATH. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH # as_fn_error STATUS ERROR [LINENO LOG_FD] # ---------------------------------------- # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are # provided, also output the error to LOG_FD, referencing LINENO. Then exit the # script with STATUS, using 1 if that was 0. as_fn_error () { as_status=$1; test $as_status -eq 0 && as_status=1 if test "$4"; then as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi $as_echo "$as_me: error: $2" >&2 as_fn_exit $as_status } # as_fn_error # as_fn_set_status STATUS # ----------------------- # Set $? to STATUS, without forking. as_fn_set_status () { return $1 } # as_fn_set_status # as_fn_exit STATUS # ----------------- # Exit the shell with STATUS, even in a "trap 0" or "set -e" context. as_fn_exit () { set +e as_fn_set_status $1 exit $1 } # as_fn_exit # as_fn_unset VAR # --------------- # Portably unset VAR. as_fn_unset () { { eval $1=; unset $1;} } as_unset=as_fn_unset # as_fn_append VAR VALUE # ---------------------- # Append the text in VALUE to the end of the definition contained in VAR. Take # advantage of any shell optimizations that allow amortized linear growth over # repeated appends, instead of the typical quadratic growth present in naive # implementations. if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : eval 'as_fn_append () { eval $1+=\$2 }' else as_fn_append () { eval $1=\$$1\$2 } fi # as_fn_append # as_fn_arith ARG... # ------------------ # Perform arithmetic evaluation on the ARGs, and store the result in the # global $as_val. Take advantage of shells that can avoid forks. The arguments # must be portable across $(()) and expr. if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : eval 'as_fn_arith () { as_val=$(( $* )) }' else as_fn_arith () { as_val=`expr "$@" || test $? -eq 1` } fi # as_fn_arith if expr a : '\(a\)' >/dev/null 2>&1 && test "X`expr 00001 : '.*\(...\)'`" = X001; then as_expr=expr else as_expr=false fi if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then as_basename=basename else as_basename=false fi if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then as_dirname=dirname else as_dirname=false fi as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || $as_echo X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q } /^X\/\(\/\/\)$/{ s//\1/ q } /^X\/\(\/\).*/{ s//\1/ q } s/.*/./; q'` # Avoid depending upon Character Ranges. as_cr_letters='abcdefghijklmnopqrstuvwxyz' as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' as_cr_Letters=$as_cr_letters$as_cr_LETTERS as_cr_digits='0123456789' as_cr_alnum=$as_cr_Letters$as_cr_digits ECHO_C= ECHO_N= ECHO_T= case `echo -n x` in #((((( -n*) case `echo 'xy\c'` in *c*) ECHO_T=' ';; # ECHO_T is single tab character. xy) ECHO_C='\c';; *) echo `echo ksh88 bug on AIX 6.1` > /dev/null ECHO_T=' ';; esac;; *) ECHO_N='-n';; esac rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file else rm -f conf$$.dir mkdir conf$$.dir 2>/dev/null fi if (echo >conf$$.file) 2>/dev/null; then if ln -s conf$$.file conf$$ 2>/dev/null; then as_ln_s='ln -s' # ... but there are two gotchas: # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. # In both cases, we have to default to `cp -pR'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || as_ln_s='cp -pR' elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else as_ln_s='cp -pR' fi else as_ln_s='cp -pR' fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null # as_fn_mkdir_p # ------------- # Create "$as_dir" as a directory, including parents if necessary. as_fn_mkdir_p () { case $as_dir in #( -*) as_dir=./$as_dir;; esac test -d "$as_dir" || eval $as_mkdir_p || { as_dirs= while :; do case $as_dir in #( *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( *) as_qdir=$as_dir;; esac as_dirs="'$as_qdir' $as_dirs" as_dir=`$as_dirname -- "$as_dir" || $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` test -d "$as_dir" && break done test -z "$as_dirs" || eval "mkdir $as_dirs" } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" } # as_fn_mkdir_p if mkdir -p . 2>/dev/null; then as_mkdir_p='mkdir -p "$as_dir"' else test -d ./-p && rmdir ./-p as_mkdir_p=false fi # as_fn_executable_p FILE # ----------------------- # Test if FILE is an executable regular file. as_fn_executable_p () { test -f "$1" && test -x "$1" } # as_fn_executable_p as_test_x='test -x' as_executable_p=as_fn_executable_p # Sed expression to map a string onto a valid CPP name. as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" # Sed expression to map a string onto a valid variable name. as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" exec 6>&1 ## ----------------------------------- ## ## Main body of $CONFIG_STATUS script. ## ## ----------------------------------- ## _ASEOF test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1 cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # Save the log message, to keep $0 and so on meaningful, and to # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" This file was extended by mmdb $as_me 1.25.5, which was generated by GNU Autoconf 2.69. Invocation command line was CONFIG_FILES = $CONFIG_FILES CONFIG_HEADERS = $CONFIG_HEADERS CONFIG_LINKS = $CONFIG_LINKS CONFIG_COMMANDS = $CONFIG_COMMANDS $ $0 $@ on `(hostname || uname -n) 2>/dev/null | sed 1q` " _ACEOF case $ac_config_files in *" "*) set x $ac_config_files; shift; ac_config_files=$*;; esac case $ac_config_headers in *" "*) set x $ac_config_headers; shift; ac_config_headers=$*;; esac cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 # Files that config.status was made for. config_files="$ac_config_files" config_headers="$ac_config_headers" config_commands="$ac_config_commands" _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 ac_cs_usage="\ \`$as_me' instantiates files and other configuration actions from templates according to the current configuration. Unless the files and actions are specified as TAGs, all are instantiated by default. Usage: $0 [OPTION]... [TAG]... -h, --help print this help, then exit -V, --version print version number and configuration settings, then exit --config print configuration, then exit -q, --quiet, --silent do not print progress messages -d, --debug don't remove temporary files --recheck update $as_me by reconfiguring in the same conditions --file=FILE[:TEMPLATE] instantiate the configuration file FILE --header=FILE[:TEMPLATE] instantiate the configuration header FILE Configuration files: $config_files Configuration headers: $config_headers Configuration commands: $config_commands Report bugs to the package provider." _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" ac_cs_version="\\ mmdb config.status 1.25.5 configured by $0, generated by GNU Autoconf 2.69, with options \\"\$ac_cs_config\\" Copyright (C) 2012 Free Software Foundation, Inc. This config.status script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it." ac_pwd='$ac_pwd' srcdir='$srcdir' INSTALL='$INSTALL' MKDIR_P='$MKDIR_P' AWK='$AWK' test -n "\$AWK" || AWK=awk _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # The default lists apply if the user does not specify any file. ac_need_defaults=: while test $# != 0 do case $1 in --*=?*) ac_option=`expr "X$1" : 'X\([^=]*\)='` ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'` ac_shift=: ;; --*=) ac_option=`expr "X$1" : 'X\([^=]*\)='` ac_optarg= ac_shift=: ;; *) ac_option=$1 ac_optarg=$2 ac_shift=shift ;; esac case $ac_option in # Handling of the options. -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) ac_cs_recheck=: ;; --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) $as_echo "$ac_cs_version"; exit ;; --config | --confi | --conf | --con | --co | --c ) $as_echo "$ac_cs_config"; exit ;; --debug | --debu | --deb | --de | --d | -d ) debug=: ;; --file | --fil | --fi | --f ) $ac_shift case $ac_optarg in *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; '') as_fn_error $? "missing file argument" ;; esac as_fn_append CONFIG_FILES " '$ac_optarg'" ac_need_defaults=false;; --header | --heade | --head | --hea ) $ac_shift case $ac_optarg in *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; esac as_fn_append CONFIG_HEADERS " '$ac_optarg'" ac_need_defaults=false;; --he | --h) # Conflict between --help and --header as_fn_error $? "ambiguous option: \`$1' Try \`$0 --help' for more information.";; --help | --hel | -h ) $as_echo "$ac_cs_usage"; exit ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil | --si | --s) ac_cs_silent=: ;; # This is an error. -*) as_fn_error $? "unrecognized option: \`$1' Try \`$0 --help' for more information." ;; *) as_fn_append ac_config_targets " $1" ac_need_defaults=false ;; esac shift done ac_configure_extra_args= if $ac_cs_silent; then exec 6>/dev/null ac_configure_extra_args="$ac_configure_extra_args --silent" fi _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 if \$ac_cs_recheck; then set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion shift \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6 CONFIG_SHELL='$SHELL' export CONFIG_SHELL exec "\$@" fi _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 exec 5>>config.log { echo sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX ## Running $as_me. ## _ASBOX $as_echo "$ac_log" } >&5 _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 # # INIT-COMMANDS # AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir" # The HP-UX ksh and POSIX shell print the target directory to stdout # if CDPATH is set. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH sed_quote_subst='$sed_quote_subst' double_quote_subst='$double_quote_subst' delay_variable_subst='$delay_variable_subst' macro_version='`$ECHO "$macro_version" | $SED "$delay_single_quote_subst"`' macro_revision='`$ECHO "$macro_revision" | $SED "$delay_single_quote_subst"`' enable_shared='`$ECHO "$enable_shared" | $SED "$delay_single_quote_subst"`' AS='`$ECHO "$AS" | $SED "$delay_single_quote_subst"`' DLLTOOL='`$ECHO "$DLLTOOL" | $SED "$delay_single_quote_subst"`' OBJDUMP='`$ECHO "$OBJDUMP" | $SED "$delay_single_quote_subst"`' enable_static='`$ECHO "$enable_static" | $SED "$delay_single_quote_subst"`' pic_mode='`$ECHO "$pic_mode" | $SED "$delay_single_quote_subst"`' enable_fast_install='`$ECHO "$enable_fast_install" | $SED "$delay_single_quote_subst"`' SHELL='`$ECHO "$SHELL" | $SED "$delay_single_quote_subst"`' ECHO='`$ECHO "$ECHO" | $SED "$delay_single_quote_subst"`' host_alias='`$ECHO "$host_alias" | $SED "$delay_single_quote_subst"`' host='`$ECHO "$host" | $SED "$delay_single_quote_subst"`' host_os='`$ECHO "$host_os" | $SED "$delay_single_quote_subst"`' build_alias='`$ECHO "$build_alias" | $SED "$delay_single_quote_subst"`' build='`$ECHO "$build" | $SED "$delay_single_quote_subst"`' build_os='`$ECHO "$build_os" | $SED "$delay_single_quote_subst"`' SED='`$ECHO "$SED" | $SED "$delay_single_quote_subst"`' Xsed='`$ECHO "$Xsed" | $SED "$delay_single_quote_subst"`' GREP='`$ECHO "$GREP" | $SED "$delay_single_quote_subst"`' EGREP='`$ECHO "$EGREP" | $SED "$delay_single_quote_subst"`' FGREP='`$ECHO "$FGREP" | $SED "$delay_single_quote_subst"`' LD='`$ECHO "$LD" | $SED "$delay_single_quote_subst"`' NM='`$ECHO "$NM" | $SED "$delay_single_quote_subst"`' LN_S='`$ECHO "$LN_S" | $SED "$delay_single_quote_subst"`' max_cmd_len='`$ECHO "$max_cmd_len" | $SED "$delay_single_quote_subst"`' ac_objext='`$ECHO "$ac_objext" | $SED "$delay_single_quote_subst"`' exeext='`$ECHO "$exeext" | $SED "$delay_single_quote_subst"`' lt_unset='`$ECHO "$lt_unset" | $SED "$delay_single_quote_subst"`' lt_SP2NL='`$ECHO "$lt_SP2NL" | $SED "$delay_single_quote_subst"`' lt_NL2SP='`$ECHO "$lt_NL2SP" | $SED "$delay_single_quote_subst"`' lt_cv_to_host_file_cmd='`$ECHO "$lt_cv_to_host_file_cmd" | $SED "$delay_single_quote_subst"`' lt_cv_to_tool_file_cmd='`$ECHO "$lt_cv_to_tool_file_cmd" | $SED "$delay_single_quote_subst"`' reload_flag='`$ECHO "$reload_flag" | $SED "$delay_single_quote_subst"`' reload_cmds='`$ECHO "$reload_cmds" | $SED "$delay_single_quote_subst"`' deplibs_check_method='`$ECHO "$deplibs_check_method" | $SED "$delay_single_quote_subst"`' file_magic_cmd='`$ECHO "$file_magic_cmd" | $SED "$delay_single_quote_subst"`' file_magic_glob='`$ECHO "$file_magic_glob" | $SED "$delay_single_quote_subst"`' want_nocaseglob='`$ECHO "$want_nocaseglob" | $SED "$delay_single_quote_subst"`' sharedlib_from_linklib_cmd='`$ECHO "$sharedlib_from_linklib_cmd" | $SED "$delay_single_quote_subst"`' AR='`$ECHO "$AR" | $SED "$delay_single_quote_subst"`' AR_FLAGS='`$ECHO "$AR_FLAGS" | $SED "$delay_single_quote_subst"`' archiver_list_spec='`$ECHO "$archiver_list_spec" | $SED "$delay_single_quote_subst"`' STRIP='`$ECHO "$STRIP" | $SED "$delay_single_quote_subst"`' RANLIB='`$ECHO "$RANLIB" | $SED "$delay_single_quote_subst"`' old_postinstall_cmds='`$ECHO "$old_postinstall_cmds" | $SED "$delay_single_quote_subst"`' old_postuninstall_cmds='`$ECHO "$old_postuninstall_cmds" | $SED "$delay_single_quote_subst"`' old_archive_cmds='`$ECHO "$old_archive_cmds" | $SED "$delay_single_quote_subst"`' lock_old_archive_extraction='`$ECHO "$lock_old_archive_extraction" | $SED "$delay_single_quote_subst"`' CC='`$ECHO "$CC" | $SED "$delay_single_quote_subst"`' CFLAGS='`$ECHO "$CFLAGS" | $SED "$delay_single_quote_subst"`' compiler='`$ECHO "$compiler" | $SED "$delay_single_quote_subst"`' GCC='`$ECHO "$GCC" | $SED "$delay_single_quote_subst"`' lt_cv_sys_global_symbol_pipe='`$ECHO "$lt_cv_sys_global_symbol_pipe" | $SED "$delay_single_quote_subst"`' lt_cv_sys_global_symbol_to_cdecl='`$ECHO "$lt_cv_sys_global_symbol_to_cdecl" | $SED "$delay_single_quote_subst"`' lt_cv_sys_global_symbol_to_c_name_address='`$ECHO "$lt_cv_sys_global_symbol_to_c_name_address" | $SED "$delay_single_quote_subst"`' lt_cv_sys_global_symbol_to_c_name_address_lib_prefix='`$ECHO "$lt_cv_sys_global_symbol_to_c_name_address_lib_prefix" | $SED "$delay_single_quote_subst"`' nm_file_list_spec='`$ECHO "$nm_file_list_spec" | $SED "$delay_single_quote_subst"`' lt_sysroot='`$ECHO "$lt_sysroot" | $SED "$delay_single_quote_subst"`' objdir='`$ECHO "$objdir" | $SED "$delay_single_quote_subst"`' MAGIC_CMD='`$ECHO "$MAGIC_CMD" | $SED "$delay_single_quote_subst"`' lt_prog_compiler_no_builtin_flag='`$ECHO "$lt_prog_compiler_no_builtin_flag" | $SED "$delay_single_quote_subst"`' lt_prog_compiler_pic='`$ECHO "$lt_prog_compiler_pic" | $SED "$delay_single_quote_subst"`' lt_prog_compiler_wl='`$ECHO "$lt_prog_compiler_wl" | $SED "$delay_single_quote_subst"`' lt_prog_compiler_static='`$ECHO "$lt_prog_compiler_static" | $SED "$delay_single_quote_subst"`' lt_cv_prog_compiler_c_o='`$ECHO "$lt_cv_prog_compiler_c_o" | $SED "$delay_single_quote_subst"`' need_locks='`$ECHO "$need_locks" | $SED "$delay_single_quote_subst"`' MANIFEST_TOOL='`$ECHO "$MANIFEST_TOOL" | $SED "$delay_single_quote_subst"`' DSYMUTIL='`$ECHO "$DSYMUTIL" | $SED "$delay_single_quote_subst"`' NMEDIT='`$ECHO "$NMEDIT" | $SED "$delay_single_quote_subst"`' LIPO='`$ECHO "$LIPO" | $SED "$delay_single_quote_subst"`' OTOOL='`$ECHO "$OTOOL" | $SED "$delay_single_quote_subst"`' OTOOL64='`$ECHO "$OTOOL64" | $SED "$delay_single_quote_subst"`' libext='`$ECHO "$libext" | $SED "$delay_single_quote_subst"`' shrext_cmds='`$ECHO "$shrext_cmds" | $SED "$delay_single_quote_subst"`' extract_expsyms_cmds='`$ECHO "$extract_expsyms_cmds" | $SED "$delay_single_quote_subst"`' archive_cmds_need_lc='`$ECHO "$archive_cmds_need_lc" | $SED "$delay_single_quote_subst"`' enable_shared_with_static_runtimes='`$ECHO "$enable_shared_with_static_runtimes" | $SED "$delay_single_quote_subst"`' export_dynamic_flag_spec='`$ECHO "$export_dynamic_flag_spec" | $SED "$delay_single_quote_subst"`' whole_archive_flag_spec='`$ECHO "$whole_archive_flag_spec" | $SED "$delay_single_quote_subst"`' compiler_needs_object='`$ECHO "$compiler_needs_object" | $SED "$delay_single_quote_subst"`' old_archive_from_new_cmds='`$ECHO "$old_archive_from_new_cmds" | $SED "$delay_single_quote_subst"`' old_archive_from_expsyms_cmds='`$ECHO "$old_archive_from_expsyms_cmds" | $SED "$delay_single_quote_subst"`' archive_cmds='`$ECHO "$archive_cmds" | $SED "$delay_single_quote_subst"`' archive_expsym_cmds='`$ECHO "$archive_expsym_cmds" | $SED "$delay_single_quote_subst"`' module_cmds='`$ECHO "$module_cmds" | $SED "$delay_single_quote_subst"`' module_expsym_cmds='`$ECHO "$module_expsym_cmds" | $SED "$delay_single_quote_subst"`' with_gnu_ld='`$ECHO "$with_gnu_ld" | $SED "$delay_single_quote_subst"`' allow_undefined_flag='`$ECHO "$allow_undefined_flag" | $SED "$delay_single_quote_subst"`' no_undefined_flag='`$ECHO "$no_undefined_flag" | $SED "$delay_single_quote_subst"`' hardcode_libdir_flag_spec='`$ECHO "$hardcode_libdir_flag_spec" | $SED "$delay_single_quote_subst"`' hardcode_libdir_flag_spec_ld='`$ECHO "$hardcode_libdir_flag_spec_ld" | $SED "$delay_single_quote_subst"`' hardcode_libdir_separator='`$ECHO "$hardcode_libdir_separator" | $SED "$delay_single_quote_subst"`' hardcode_direct='`$ECHO "$hardcode_direct" | $SED "$delay_single_quote_subst"`' hardcode_direct_absolute='`$ECHO "$hardcode_direct_absolute" | $SED "$delay_single_quote_subst"`' hardcode_minus_L='`$ECHO "$hardcode_minus_L" | $SED "$delay_single_quote_subst"`' hardcode_shlibpath_var='`$ECHO "$hardcode_shlibpath_var" | $SED "$delay_single_quote_subst"`' hardcode_automatic='`$ECHO "$hardcode_automatic" | $SED "$delay_single_quote_subst"`' inherit_rpath='`$ECHO "$inherit_rpath" | $SED "$delay_single_quote_subst"`' link_all_deplibs='`$ECHO "$link_all_deplibs" | $SED "$delay_single_quote_subst"`' always_export_symbols='`$ECHO "$always_export_symbols" | $SED "$delay_single_quote_subst"`' export_symbols_cmds='`$ECHO "$export_symbols_cmds" | $SED "$delay_single_quote_subst"`' exclude_expsyms='`$ECHO "$exclude_expsyms" | $SED "$delay_single_quote_subst"`' include_expsyms='`$ECHO "$include_expsyms" | $SED "$delay_single_quote_subst"`' prelink_cmds='`$ECHO "$prelink_cmds" | $SED "$delay_single_quote_subst"`' postlink_cmds='`$ECHO "$postlink_cmds" | $SED "$delay_single_quote_subst"`' file_list_spec='`$ECHO "$file_list_spec" | $SED "$delay_single_quote_subst"`' variables_saved_for_relink='`$ECHO "$variables_saved_for_relink" | $SED "$delay_single_quote_subst"`' need_lib_prefix='`$ECHO "$need_lib_prefix" | $SED "$delay_single_quote_subst"`' need_version='`$ECHO "$need_version" | $SED "$delay_single_quote_subst"`' version_type='`$ECHO "$version_type" | $SED "$delay_single_quote_subst"`' runpath_var='`$ECHO "$runpath_var" | $SED "$delay_single_quote_subst"`' shlibpath_var='`$ECHO "$shlibpath_var" | $SED "$delay_single_quote_subst"`' shlibpath_overrides_runpath='`$ECHO "$shlibpath_overrides_runpath" | $SED "$delay_single_quote_subst"`' libname_spec='`$ECHO "$libname_spec" | $SED "$delay_single_quote_subst"`' library_names_spec='`$ECHO "$library_names_spec" | $SED "$delay_single_quote_subst"`' soname_spec='`$ECHO "$soname_spec" | $SED "$delay_single_quote_subst"`' install_override_mode='`$ECHO "$install_override_mode" | $SED "$delay_single_quote_subst"`' postinstall_cmds='`$ECHO "$postinstall_cmds" | $SED "$delay_single_quote_subst"`' postuninstall_cmds='`$ECHO "$postuninstall_cmds" | $SED "$delay_single_quote_subst"`' finish_cmds='`$ECHO "$finish_cmds" | $SED "$delay_single_quote_subst"`' finish_eval='`$ECHO "$finish_eval" | $SED "$delay_single_quote_subst"`' hardcode_into_libs='`$ECHO "$hardcode_into_libs" | $SED "$delay_single_quote_subst"`' sys_lib_search_path_spec='`$ECHO "$sys_lib_search_path_spec" | $SED "$delay_single_quote_subst"`' sys_lib_dlsearch_path_spec='`$ECHO "$sys_lib_dlsearch_path_spec" | $SED "$delay_single_quote_subst"`' hardcode_action='`$ECHO "$hardcode_action" | $SED "$delay_single_quote_subst"`' enable_dlopen='`$ECHO "$enable_dlopen" | $SED "$delay_single_quote_subst"`' enable_dlopen_self='`$ECHO "$enable_dlopen_self" | $SED "$delay_single_quote_subst"`' enable_dlopen_self_static='`$ECHO "$enable_dlopen_self_static" | $SED "$delay_single_quote_subst"`' old_striplib='`$ECHO "$old_striplib" | $SED "$delay_single_quote_subst"`' striplib='`$ECHO "$striplib" | $SED "$delay_single_quote_subst"`' compiler_lib_search_dirs='`$ECHO "$compiler_lib_search_dirs" | $SED "$delay_single_quote_subst"`' predep_objects='`$ECHO "$predep_objects" | $SED "$delay_single_quote_subst"`' postdep_objects='`$ECHO "$postdep_objects" | $SED "$delay_single_quote_subst"`' predeps='`$ECHO "$predeps" | $SED "$delay_single_quote_subst"`' postdeps='`$ECHO "$postdeps" | $SED "$delay_single_quote_subst"`' compiler_lib_search_path='`$ECHO "$compiler_lib_search_path" | $SED "$delay_single_quote_subst"`' LD_CXX='`$ECHO "$LD_CXX" | $SED "$delay_single_quote_subst"`' reload_flag_CXX='`$ECHO "$reload_flag_CXX" | $SED "$delay_single_quote_subst"`' reload_cmds_CXX='`$ECHO "$reload_cmds_CXX" | $SED "$delay_single_quote_subst"`' old_archive_cmds_CXX='`$ECHO "$old_archive_cmds_CXX" | $SED "$delay_single_quote_subst"`' compiler_CXX='`$ECHO "$compiler_CXX" | $SED "$delay_single_quote_subst"`' GCC_CXX='`$ECHO "$GCC_CXX" | $SED "$delay_single_quote_subst"`' lt_prog_compiler_no_builtin_flag_CXX='`$ECHO "$lt_prog_compiler_no_builtin_flag_CXX" | $SED "$delay_single_quote_subst"`' lt_prog_compiler_pic_CXX='`$ECHO "$lt_prog_compiler_pic_CXX" | $SED "$delay_single_quote_subst"`' lt_prog_compiler_wl_CXX='`$ECHO "$lt_prog_compiler_wl_CXX" | $SED "$delay_single_quote_subst"`' lt_prog_compiler_static_CXX='`$ECHO "$lt_prog_compiler_static_CXX" | $SED "$delay_single_quote_subst"`' lt_cv_prog_compiler_c_o_CXX='`$ECHO "$lt_cv_prog_compiler_c_o_CXX" | $SED "$delay_single_quote_subst"`' archive_cmds_need_lc_CXX='`$ECHO "$archive_cmds_need_lc_CXX" | $SED "$delay_single_quote_subst"`' enable_shared_with_static_runtimes_CXX='`$ECHO "$enable_shared_with_static_runtimes_CXX" | $SED "$delay_single_quote_subst"`' export_dynamic_flag_spec_CXX='`$ECHO "$export_dynamic_flag_spec_CXX" | $SED "$delay_single_quote_subst"`' whole_archive_flag_spec_CXX='`$ECHO "$whole_archive_flag_spec_CXX" | $SED "$delay_single_quote_subst"`' compiler_needs_object_CXX='`$ECHO "$compiler_needs_object_CXX" | $SED "$delay_single_quote_subst"`' old_archive_from_new_cmds_CXX='`$ECHO "$old_archive_from_new_cmds_CXX" | $SED "$delay_single_quote_subst"`' old_archive_from_expsyms_cmds_CXX='`$ECHO "$old_archive_from_expsyms_cmds_CXX" | $SED "$delay_single_quote_subst"`' archive_cmds_CXX='`$ECHO "$archive_cmds_CXX" | $SED "$delay_single_quote_subst"`' archive_expsym_cmds_CXX='`$ECHO "$archive_expsym_cmds_CXX" | $SED "$delay_single_quote_subst"`' module_cmds_CXX='`$ECHO "$module_cmds_CXX" | $SED "$delay_single_quote_subst"`' module_expsym_cmds_CXX='`$ECHO "$module_expsym_cmds_CXX" | $SED "$delay_single_quote_subst"`' with_gnu_ld_CXX='`$ECHO "$with_gnu_ld_CXX" | $SED "$delay_single_quote_subst"`' allow_undefined_flag_CXX='`$ECHO "$allow_undefined_flag_CXX" | $SED "$delay_single_quote_subst"`' no_undefined_flag_CXX='`$ECHO "$no_undefined_flag_CXX" | $SED "$delay_single_quote_subst"`' hardcode_libdir_flag_spec_CXX='`$ECHO "$hardcode_libdir_flag_spec_CXX" | $SED "$delay_single_quote_subst"`' hardcode_libdir_flag_spec_ld_CXX='`$ECHO "$hardcode_libdir_flag_spec_ld_CXX" | $SED "$delay_single_quote_subst"`' hardcode_libdir_separator_CXX='`$ECHO "$hardcode_libdir_separator_CXX" | $SED "$delay_single_quote_subst"`' hardcode_direct_CXX='`$ECHO "$hardcode_direct_CXX" | $SED "$delay_single_quote_subst"`' hardcode_direct_absolute_CXX='`$ECHO "$hardcode_direct_absolute_CXX" | $SED "$delay_single_quote_subst"`' hardcode_minus_L_CXX='`$ECHO "$hardcode_minus_L_CXX" | $SED "$delay_single_quote_subst"`' hardcode_shlibpath_var_CXX='`$ECHO "$hardcode_shlibpath_var_CXX" | $SED "$delay_single_quote_subst"`' hardcode_automatic_CXX='`$ECHO "$hardcode_automatic_CXX" | $SED "$delay_single_quote_subst"`' inherit_rpath_CXX='`$ECHO "$inherit_rpath_CXX" | $SED "$delay_single_quote_subst"`' link_all_deplibs_CXX='`$ECHO "$link_all_deplibs_CXX" | $SED "$delay_single_quote_subst"`' always_export_symbols_CXX='`$ECHO "$always_export_symbols_CXX" | $SED "$delay_single_quote_subst"`' export_symbols_cmds_CXX='`$ECHO "$export_symbols_cmds_CXX" | $SED "$delay_single_quote_subst"`' exclude_expsyms_CXX='`$ECHO "$exclude_expsyms_CXX" | $SED "$delay_single_quote_subst"`' include_expsyms_CXX='`$ECHO "$include_expsyms_CXX" | $SED "$delay_single_quote_subst"`' prelink_cmds_CXX='`$ECHO "$prelink_cmds_CXX" | $SED "$delay_single_quote_subst"`' postlink_cmds_CXX='`$ECHO "$postlink_cmds_CXX" | $SED "$delay_single_quote_subst"`' file_list_spec_CXX='`$ECHO "$file_list_spec_CXX" | $SED "$delay_single_quote_subst"`' hardcode_action_CXX='`$ECHO "$hardcode_action_CXX" | $SED "$delay_single_quote_subst"`' compiler_lib_search_dirs_CXX='`$ECHO "$compiler_lib_search_dirs_CXX" | $SED "$delay_single_quote_subst"`' predep_objects_CXX='`$ECHO "$predep_objects_CXX" | $SED "$delay_single_quote_subst"`' postdep_objects_CXX='`$ECHO "$postdep_objects_CXX" | $SED "$delay_single_quote_subst"`' predeps_CXX='`$ECHO "$predeps_CXX" | $SED "$delay_single_quote_subst"`' postdeps_CXX='`$ECHO "$postdeps_CXX" | $SED "$delay_single_quote_subst"`' compiler_lib_search_path_CXX='`$ECHO "$compiler_lib_search_path_CXX" | $SED "$delay_single_quote_subst"`' LTCC='$LTCC' LTCFLAGS='$LTCFLAGS' compiler='$compiler_DEFAULT' # A function that is used when there is no print builtin or printf. func_fallback_echo () { eval 'cat <<_LTECHO_EOF \$1 _LTECHO_EOF' } # Quote evaled strings. for var in AS \ DLLTOOL \ OBJDUMP \ SHELL \ ECHO \ SED \ GREP \ EGREP \ FGREP \ LD \ NM \ LN_S \ lt_SP2NL \ lt_NL2SP \ reload_flag \ deplibs_check_method \ file_magic_cmd \ file_magic_glob \ want_nocaseglob \ sharedlib_from_linklib_cmd \ AR \ AR_FLAGS \ archiver_list_spec \ STRIP \ RANLIB \ CC \ CFLAGS \ compiler \ lt_cv_sys_global_symbol_pipe \ lt_cv_sys_global_symbol_to_cdecl \ lt_cv_sys_global_symbol_to_c_name_address \ lt_cv_sys_global_symbol_to_c_name_address_lib_prefix \ nm_file_list_spec \ lt_prog_compiler_no_builtin_flag \ lt_prog_compiler_pic \ lt_prog_compiler_wl \ lt_prog_compiler_static \ lt_cv_prog_compiler_c_o \ need_locks \ MANIFEST_TOOL \ DSYMUTIL \ NMEDIT \ LIPO \ OTOOL \ OTOOL64 \ shrext_cmds \ export_dynamic_flag_spec \ whole_archive_flag_spec \ compiler_needs_object \ with_gnu_ld \ allow_undefined_flag \ no_undefined_flag \ hardcode_libdir_flag_spec \ hardcode_libdir_flag_spec_ld \ hardcode_libdir_separator \ exclude_expsyms \ include_expsyms \ file_list_spec \ variables_saved_for_relink \ libname_spec \ library_names_spec \ soname_spec \ install_override_mode \ finish_eval \ old_striplib \ striplib \ compiler_lib_search_dirs \ predep_objects \ postdep_objects \ predeps \ postdeps \ compiler_lib_search_path \ LD_CXX \ reload_flag_CXX \ compiler_CXX \ lt_prog_compiler_no_builtin_flag_CXX \ lt_prog_compiler_pic_CXX \ lt_prog_compiler_wl_CXX \ lt_prog_compiler_static_CXX \ lt_cv_prog_compiler_c_o_CXX \ export_dynamic_flag_spec_CXX \ whole_archive_flag_spec_CXX \ compiler_needs_object_CXX \ with_gnu_ld_CXX \ allow_undefined_flag_CXX \ no_undefined_flag_CXX \ hardcode_libdir_flag_spec_CXX \ hardcode_libdir_flag_spec_ld_CXX \ hardcode_libdir_separator_CXX \ exclude_expsyms_CXX \ include_expsyms_CXX \ file_list_spec_CXX \ compiler_lib_search_dirs_CXX \ predep_objects_CXX \ postdep_objects_CXX \ predeps_CXX \ postdeps_CXX \ compiler_lib_search_path_CXX; do case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in *[\\\\\\\`\\"\\\$]*) eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\"" ;; *) eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" ;; esac done # Double-quote double-evaled strings. for var in reload_cmds \ old_postinstall_cmds \ old_postuninstall_cmds \ old_archive_cmds \ extract_expsyms_cmds \ old_archive_from_new_cmds \ old_archive_from_expsyms_cmds \ archive_cmds \ archive_expsym_cmds \ module_cmds \ module_expsym_cmds \ export_symbols_cmds \ prelink_cmds \ postlink_cmds \ postinstall_cmds \ postuninstall_cmds \ finish_cmds \ sys_lib_search_path_spec \ sys_lib_dlsearch_path_spec \ reload_cmds_CXX \ old_archive_cmds_CXX \ old_archive_from_new_cmds_CXX \ old_archive_from_expsyms_cmds_CXX \ archive_cmds_CXX \ archive_expsym_cmds_CXX \ module_cmds_CXX \ module_expsym_cmds_CXX \ export_symbols_cmds_CXX \ prelink_cmds_CXX \ postlink_cmds_CXX; do case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in *[\\\\\\\`\\"\\\$]*) eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\"" ;; *) eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" ;; esac done ac_aux_dir='$ac_aux_dir' xsi_shell='$xsi_shell' lt_shell_append='$lt_shell_append' # See if we are running on zsh, and set the options which allow our # commands through without removal of \ escapes INIT. if test -n "\${ZSH_VERSION+set}" ; then setopt NO_GLOB_SUBST fi PACKAGE='$PACKAGE' VERSION='$VERSION' TIMESTAMP='$TIMESTAMP' RM='$RM' ofile='$ofile' _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # Handling of arguments. for ac_config_target in $ac_config_targets do case $ac_config_target in "config.h") CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;; "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;; "libtool") CONFIG_COMMANDS="$CONFIG_COMMANDS libtool" ;; "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;; "mmdb.pc") CONFIG_FILES="$CONFIG_FILES mmdb.pc" ;; *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;; esac done # If the user did not use the arguments to specify the items to instantiate, # then the envvar interface is used. Set only those that are not. # We use the long form for the default assignment because of an extremely # bizarre bug on SunOS 4.1.3. if $ac_need_defaults; then test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands fi # Have a temporary directory for convenience. Make it in the build tree # simply because there is no reason against having it here, and in addition, # creating and moving files from /tmp can sometimes cause problems. # Hook for its removal unless debugging. # Note that there is a small window in which the directory will not be cleaned: # after its creation but before its name has been assigned to `$tmp'. $debug || { tmp= ac_tmp= trap 'exit_status=$? : "${ac_tmp:=$tmp}" { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status ' 0 trap 'as_fn_exit 1' 1 2 13 15 } # Create a (secure) tmp directory for tmp files. { tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` && test -d "$tmp" } || { tmp=./conf$$-$RANDOM (umask 077 && mkdir "$tmp") } || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5 ac_tmp=$tmp # Set up the scripts for CONFIG_FILES section. # No need to generate them if there are no CONFIG_FILES. # This happens for instance with `./config.status config.h'. if test -n "$CONFIG_FILES"; then ac_cr=`echo X | tr X '\015'` # On cygwin, bash can eat \r inside `` if the user requested igncr. # But we know of no other shell where ac_cr would be empty at this # point, so we can use a bashism as a fallback. if test "x$ac_cr" = x; then eval ac_cr=\$\'\\r\' fi ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' /dev/null` if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then ac_cs_awk_cr='\\r' else ac_cs_awk_cr=$ac_cr fi echo 'BEGIN {' >"$ac_tmp/subs1.awk" && _ACEOF { echo "cat >conf$$subs.awk <<_ACEOF" && echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' && echo "_ACEOF" } >conf$$subs.sh || as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'` ac_delim='%!_!# ' for ac_last_try in false false false false false :; do . ./conf$$subs.sh || as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X` if test $ac_delim_n = $ac_delim_num; then break elif $ac_last_try; then as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 else ac_delim="$ac_delim!$ac_delim _$ac_delim!! " fi done rm -f conf$$subs.sh cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK && _ACEOF sed -n ' h s/^/S["/; s/!.*/"]=/ p g s/^[^!]*!// :repl t repl s/'"$ac_delim"'$// t delim :nl h s/\(.\{148\}\)..*/\1/ t more1 s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/ p n b repl :more1 s/["\\]/\\&/g; s/^/"/; s/$/"\\/ p g s/.\{148\}// t nl :delim h s/\(.\{148\}\)..*/\1/ t more2 s/["\\]/\\&/g; s/^/"/; s/$/"/ p b :more2 s/["\\]/\\&/g; s/^/"/; s/$/"\\/ p g s/.\{148\}// t delim ' >$CONFIG_STATUS || ac_write_fail=1 rm -f conf$$subs.awk cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 _ACAWK cat >>"\$ac_tmp/subs1.awk" <<_ACAWK && for (key in S) S_is_set[key] = 1 FS = "" } { line = $ 0 nfields = split(line, field, "@") substed = 0 len = length(field[1]) for (i = 2; i < nfields; i++) { key = field[i] keylen = length(key) if (S_is_set[key]) { value = S[key] line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3) len += length(value) + length(field[++i]) substed = 1 } else len += 1 + keylen } print line } _ACAWK _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g" else cat fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \ || as_fn_error $? "could not setup config files machinery" "$LINENO" 5 _ACEOF # VPATH may cause trouble with some makes, so we remove sole $(srcdir), # ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and # trailing colons and then remove the whole line if VPATH becomes empty # (actually we leave an empty line to preserve line numbers). if test "x$srcdir" = x.; then ac_vpsub='/^[ ]*VPATH[ ]*=[ ]*/{ h s/// s/^/:/ s/[ ]*$/:/ s/:\$(srcdir):/:/g s/:\${srcdir}:/:/g s/:@srcdir@:/:/g s/^:*// s/:*$// x s/\(=[ ]*\).*/\1/ G s/\n// s/^[^=]*=[ ]*$// }' fi cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 fi # test -n "$CONFIG_FILES" # Set up the scripts for CONFIG_HEADERS section. # No need to generate them if there are no CONFIG_HEADERS. # This happens for instance with `./config.status Makefile'. if test -n "$CONFIG_HEADERS"; then cat >"$ac_tmp/defines.awk" <<\_ACAWK || BEGIN { _ACEOF # Transform confdefs.h into an awk script `defines.awk', embedded as # here-document in config.status, that substitutes the proper values into # config.h.in to produce config.h. # Create a delimiter string that does not exist in confdefs.h, to ease # handling of long lines. ac_delim='%!_!# ' for ac_last_try in false false :; do ac_tt=`sed -n "/$ac_delim/p" confdefs.h` if test -z "$ac_tt"; then break elif $ac_last_try; then as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5 else ac_delim="$ac_delim!$ac_delim _$ac_delim!! " fi done # For the awk script, D is an array of macro values keyed by name, # likewise P contains macro parameters if any. Preserve backslash # newline sequences. ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]* sed -n ' s/.\{148\}/&'"$ac_delim"'/g t rset :rset s/^[ ]*#[ ]*define[ ][ ]*/ / t def d :def s/\\$// t bsnl s/["\\]/\\&/g s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ D["\1"]=" \3"/p s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2"/p d :bsnl s/["\\]/\\&/g s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ D["\1"]=" \3\\\\\\n"\\/p t cont s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p t cont d :cont n s/.\{148\}/&'"$ac_delim"'/g t clear :clear s/\\$// t bsnlc s/["\\]/\\&/g; s/^/"/; s/$/"/p d :bsnlc s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p b cont ' >$CONFIG_STATUS || ac_write_fail=1 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 for (key in D) D_is_set[key] = 1 FS = "" } /^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ { line = \$ 0 split(line, arg, " ") if (arg[1] == "#") { defundef = arg[2] mac1 = arg[3] } else { defundef = substr(arg[1], 2) mac1 = arg[2] } split(mac1, mac2, "(") #) macro = mac2[1] prefix = substr(line, 1, index(line, defundef) - 1) if (D_is_set[macro]) { # Preserve the white space surrounding the "#". print prefix "define", macro P[macro] D[macro] next } else { # Replace #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. if (defundef == "undef") { print "/*", prefix defundef, macro, "*/" next } } } { print } _ACAWK _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 as_fn_error $? "could not setup config headers machinery" "$LINENO" 5 fi # test -n "$CONFIG_HEADERS" eval set X " :F $CONFIG_FILES :H $CONFIG_HEADERS :C $CONFIG_COMMANDS" shift for ac_tag do case $ac_tag in :[FHLC]) ac_mode=$ac_tag; continue;; esac case $ac_mode$ac_tag in :[FHL]*:*);; :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;; :[FH]-) ac_tag=-:-;; :[FH]*) ac_tag=$ac_tag:$ac_tag.in;; esac ac_save_IFS=$IFS IFS=: set x $ac_tag IFS=$ac_save_IFS shift ac_file=$1 shift case $ac_mode in :L) ac_source=$1;; :[FH]) ac_file_inputs= for ac_f do case $ac_f in -) ac_f="$ac_tmp/stdin";; *) # Look for the file first in the build tree, then in the source tree # (if the path is not absolute). The absolute path cannot be DOS-style, # because $ac_f cannot contain `:'. test -f "$ac_f" || case $ac_f in [\\/$]*) false;; *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; esac || as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;; esac case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac as_fn_append ac_file_inputs " '$ac_f'" done # Let's still pretend it is `configure' which instantiates (i.e., don't # use $as_me), people would be surprised to read: # /* config.h. Generated by config.status. */ configure_input='Generated from '` $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g' `' by configure.' if test x"$ac_file" != x-; then configure_input="$ac_file. $configure_input" { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 $as_echo "$as_me: creating $ac_file" >&6;} fi # Neutralize special characters interpreted by sed in replacement strings. case $configure_input in #( *\&* | *\|* | *\\* ) ac_sed_conf_input=`$as_echo "$configure_input" | sed 's/[\\\\&|]/\\\\&/g'`;; #( *) ac_sed_conf_input=$configure_input;; esac case $ac_tag in *:-:* | *:-) cat >"$ac_tmp/stdin" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; esac ;; esac ac_dir=`$as_dirname -- "$ac_file" || $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$ac_file" : 'X\(//\)[^/]' \| \ X"$ac_file" : 'X\(//\)$' \| \ X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$ac_file" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` as_dir="$ac_dir"; as_fn_mkdir_p ac_builddir=. case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` # A ".." for each directory in $ac_dir_suffix. ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; esac ;; esac ac_abs_top_builddir=$ac_pwd ac_abs_builddir=$ac_pwd$ac_dir_suffix # for backward compatibility: ac_top_builddir=$ac_top_build_prefix case $srcdir in .) # We are building in place. ac_srcdir=. ac_top_srcdir=$ac_top_builddir_sub ac_abs_top_srcdir=$ac_pwd ;; [\\/]* | ?:[\\/]* ) # Absolute name. ac_srcdir=$srcdir$ac_dir_suffix; ac_top_srcdir=$srcdir ac_abs_top_srcdir=$srcdir ;; *) # Relative name. ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix ac_top_srcdir=$ac_top_build_prefix$srcdir ac_abs_top_srcdir=$ac_pwd/$srcdir ;; esac ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix case $ac_mode in :F) # # CONFIG_FILE # case $INSTALL in [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;; *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;; esac ac_MKDIR_P=$MKDIR_P case $MKDIR_P in [\\/$]* | ?:[\\/]* ) ;; */*) ac_MKDIR_P=$ac_top_build_prefix$MKDIR_P ;; esac _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # If the template does not know about datarootdir, expand it. # FIXME: This hack should be removed a few years after 2.60. ac_datarootdir_hack=; ac_datarootdir_seen= ac_sed_dataroot=' /datarootdir/ { p q } /@datadir@/p /@docdir@/p /@infodir@/p /@localedir@/p /@mandir@/p' case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in *datarootdir*) ac_datarootdir_seen=yes;; *@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 $as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_datarootdir_hack=' s&@datadir@&$datadir&g s&@docdir@&$docdir&g s&@infodir@&$infodir&g s&@localedir@&$localedir&g s&@mandir@&$mandir&g s&\\\${datarootdir}&$datarootdir&g' ;; esac _ACEOF # Neutralize VPATH when `$srcdir' = `.'. # Shell code in configure.ac might set extrasub. # FIXME: do we really want to maintain this feature? cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_sed_extra="$ac_vpsub $extrasub _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 :t /@[a-zA-Z_][a-zA-Z_0-9]*@/!b s|@configure_input@|$ac_sed_conf_input|;t t s&@top_builddir@&$ac_top_builddir_sub&;t t s&@top_build_prefix@&$ac_top_build_prefix&;t t s&@srcdir@&$ac_srcdir&;t t s&@abs_srcdir@&$ac_abs_srcdir&;t t s&@top_srcdir@&$ac_top_srcdir&;t t s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t s&@builddir@&$ac_builddir&;t t s&@abs_builddir@&$ac_abs_builddir&;t t s&@abs_top_builddir@&$ac_abs_top_builddir&;t t s&@INSTALL@&$ac_INSTALL&;t t s&@MKDIR_P@&$ac_MKDIR_P&;t t $ac_datarootdir_hack " eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \ >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5 test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } && { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' \ "$ac_tmp/out"`; test -z "$ac_out"; } && { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined" >&5 $as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined" >&2;} rm -f "$ac_tmp/stdin" case $ac_file in -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";; *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";; esac \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; :H) # # CONFIG_HEADER # if test x"$ac_file" != x-; then { $as_echo "/* $configure_input */" \ && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" } >"$ac_tmp/config.h" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5 $as_echo "$as_me: $ac_file is unchanged" >&6;} else rm -f "$ac_file" mv "$ac_tmp/config.h" "$ac_file" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 fi else $as_echo "/* $configure_input */" \ && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \ || as_fn_error $? "could not create -" "$LINENO" 5 fi # Compute "$ac_file"'s index in $config_headers. _am_arg="$ac_file" _am_stamp_count=1 for _am_header in $config_headers :; do case $_am_header in $_am_arg | $_am_arg:* ) break ;; * ) _am_stamp_count=`expr $_am_stamp_count + 1` ;; esac done echo "timestamp for $_am_arg" >`$as_dirname -- "$_am_arg" || $as_expr X"$_am_arg" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$_am_arg" : 'X\(//\)[^/]' \| \ X"$_am_arg" : 'X\(//\)$' \| \ X"$_am_arg" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$_am_arg" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'`/stamp-h$_am_stamp_count ;; :C) { $as_echo "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5 $as_echo "$as_me: executing $ac_file commands" >&6;} ;; esac case $ac_file$ac_mode in "depfiles":C) test x"$AMDEP_TRUE" != x"" || { # Autoconf 2.62 quotes --file arguments for eval, but not when files # are listed without --file. Let's play safe and only enable the eval # if we detect the quoting. case $CONFIG_FILES in *\'*) eval set x "$CONFIG_FILES" ;; *) set x $CONFIG_FILES ;; esac shift for mf do # Strip MF so we end up with the name of the file. mf=`echo "$mf" | sed -e 's/:.*$//'` # Check whether this is an Automake generated Makefile or not. # We used to match only the files named 'Makefile.in', but # some people rename them; so instead we look at the file content. # Grep'ing the first line is not enough: some people post-process # each Makefile.in and add a new line on top of each file to say so. # Grep'ing the whole file is not good either: AIX grep has a line # limit of 2048, but all sed's we know have understand at least 4000. if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then dirpart=`$as_dirname -- "$mf" || $as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$mf" : 'X\(//\)[^/]' \| \ X"$mf" : 'X\(//\)$' \| \ X"$mf" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$mf" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` else continue fi # Extract the definition of DEPDIR, am__include, and am__quote # from the Makefile without running 'make'. DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"` test -z "$DEPDIR" && continue am__include=`sed -n 's/^am__include = //p' < "$mf"` test -z "am__include" && continue am__quote=`sed -n 's/^am__quote = //p' < "$mf"` # Find all dependency output files, they are included files with # $(DEPDIR) in their names. We invoke sed twice because it is the # simplest approach to changing $(DEPDIR) to its actual value in the # expansion. for file in `sed -n " s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \ sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do # Make sure the directory exists. test -f "$dirpart/$file" && continue fdir=`$as_dirname -- "$file" || $as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$file" : 'X\(//\)[^/]' \| \ X"$file" : 'X\(//\)$' \| \ X"$file" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$file" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` as_dir=$dirpart/$fdir; as_fn_mkdir_p # echo "creating $dirpart/$file" echo '# dummy' > "$dirpart/$file" done done } ;; "libtool":C) # See if we are running on zsh, and set the options which allow our # commands through without removal of \ escapes. if test -n "${ZSH_VERSION+set}" ; then setopt NO_GLOB_SUBST fi cfgfile="${ofile}T" trap "$RM \"$cfgfile\"; exit 1" 1 2 15 $RM "$cfgfile" cat <<_LT_EOF >> "$cfgfile" #! $SHELL # `$ECHO "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services. # Generated automatically by $as_me ($PACKAGE$TIMESTAMP) $VERSION # Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`: # NOTE: Changes made to this file will be lost: look at ltmain.sh. # # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, # 2006, 2007, 2008, 2009, 2010 Free Software Foundation, # Inc. # Written by Gordon Matzigkeit, 1996 # # This file is part of GNU Libtool. # # GNU Libtool 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. # # As a special exception to the GNU General Public License, # if you distribute this file as part of a program or library that # is built using GNU Libtool, you may include this file under the # same distribution terms that you use for the rest of that program. # # GNU Libtool 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 GNU Libtool; see the file COPYING. If not, a copy # can be downloaded from http://www.gnu.org/licenses/gpl.html, or # obtained by writing to the Free Software Foundation, Inc., # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. # The names of the tagged configurations supported by this script. available_tags="CXX " # ### BEGIN LIBTOOL CONFIG # Which release of libtool.m4 was used? macro_version=$macro_version macro_revision=$macro_revision # Whether or not to build shared libraries. build_libtool_libs=$enable_shared # Assembler program. AS=$lt_AS # DLL creation program. DLLTOOL=$lt_DLLTOOL # Object dumper program. OBJDUMP=$lt_OBJDUMP # Whether or not to build static libraries. build_old_libs=$enable_static # What type of objects to build. pic_mode=$pic_mode # Whether or not to optimize for fast installation. fast_install=$enable_fast_install # Shell to use when invoking shell scripts. SHELL=$lt_SHELL # An echo program that protects backslashes. ECHO=$lt_ECHO # The host system. host_alias=$host_alias host=$host host_os=$host_os # The build system. build_alias=$build_alias build=$build build_os=$build_os # A sed program that does not truncate output. SED=$lt_SED # Sed that helps us avoid accidentally triggering echo(1) options like -n. Xsed="\$SED -e 1s/^X//" # A grep program that handles long lines. GREP=$lt_GREP # An ERE matcher. EGREP=$lt_EGREP # A literal string matcher. FGREP=$lt_FGREP # A BSD- or MS-compatible name lister. NM=$lt_NM # Whether we need soft or hard links. LN_S=$lt_LN_S # What is the maximum length of a command? max_cmd_len=$max_cmd_len # Object file suffix (normally "o"). objext=$ac_objext # Executable file suffix (normally ""). exeext=$exeext # whether the shell understands "unset". lt_unset=$lt_unset # turn spaces into newlines. SP2NL=$lt_lt_SP2NL # turn newlines into spaces. NL2SP=$lt_lt_NL2SP # convert \$build file names to \$host format. to_host_file_cmd=$lt_cv_to_host_file_cmd # convert \$build files to toolchain format. to_tool_file_cmd=$lt_cv_to_tool_file_cmd # Method to check whether dependent libraries are shared objects. deplibs_check_method=$lt_deplibs_check_method # Command to use when deplibs_check_method = "file_magic". file_magic_cmd=$lt_file_magic_cmd # How to find potential files when deplibs_check_method = "file_magic". file_magic_glob=$lt_file_magic_glob # Find potential files using nocaseglob when deplibs_check_method = "file_magic". want_nocaseglob=$lt_want_nocaseglob # Command to associate shared and link libraries. sharedlib_from_linklib_cmd=$lt_sharedlib_from_linklib_cmd # The archiver. AR=$lt_AR # Flags to create an archive. AR_FLAGS=$lt_AR_FLAGS # How to feed a file listing to the archiver. archiver_list_spec=$lt_archiver_list_spec # A symbol stripping program. STRIP=$lt_STRIP # Commands used to install an old-style archive. RANLIB=$lt_RANLIB old_postinstall_cmds=$lt_old_postinstall_cmds old_postuninstall_cmds=$lt_old_postuninstall_cmds # Whether to use a lock for old archive extraction. lock_old_archive_extraction=$lock_old_archive_extraction # A C compiler. LTCC=$lt_CC # LTCC compiler flags. LTCFLAGS=$lt_CFLAGS # Take the output of nm and produce a listing of raw symbols and C names. global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe # Transform the output of nm in a proper C declaration. global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl # Transform the output of nm in a C name address pair. global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address # Transform the output of nm in a C name address pair when lib prefix is needed. global_symbol_to_c_name_address_lib_prefix=$lt_lt_cv_sys_global_symbol_to_c_name_address_lib_prefix # Specify filename containing input files for \$NM. nm_file_list_spec=$lt_nm_file_list_spec # The root where to search for dependent libraries,and in which our libraries should be installed. lt_sysroot=$lt_sysroot # The name of the directory that contains temporary libtool files. objdir=$objdir # Used to examine libraries when file_magic_cmd begins with "file". MAGIC_CMD=$MAGIC_CMD # Must we lock files when doing compilation? need_locks=$lt_need_locks # Manifest tool. MANIFEST_TOOL=$lt_MANIFEST_TOOL # Tool to manipulate archived DWARF debug symbol files on Mac OS X. DSYMUTIL=$lt_DSYMUTIL # Tool to change global to local symbols on Mac OS X. NMEDIT=$lt_NMEDIT # Tool to manipulate fat objects and archives on Mac OS X. LIPO=$lt_LIPO # ldd/readelf like tool for Mach-O binaries on Mac OS X. OTOOL=$lt_OTOOL # ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4. OTOOL64=$lt_OTOOL64 # Old archive suffix (normally "a"). libext=$libext # Shared library suffix (normally ".so"). shrext_cmds=$lt_shrext_cmds # The commands to extract the exported symbol list from a shared archive. extract_expsyms_cmds=$lt_extract_expsyms_cmds # Variables whose values should be saved in libtool wrapper scripts and # restored at link time. variables_saved_for_relink=$lt_variables_saved_for_relink # Do we need the "lib" prefix for modules? need_lib_prefix=$need_lib_prefix # Do we need a version for libraries? need_version=$need_version # Library versioning type. version_type=$version_type # Shared library runtime path variable. runpath_var=$runpath_var # Shared library path variable. shlibpath_var=$shlibpath_var # Is shlibpath searched before the hard-coded library search path? shlibpath_overrides_runpath=$shlibpath_overrides_runpath # Format of library name prefix. libname_spec=$lt_libname_spec # List of archive names. First name is the real one, the rest are links. # The last name is the one that the linker finds with -lNAME library_names_spec=$lt_library_names_spec # The coded name of the library, if different from the real name. soname_spec=$lt_soname_spec # Permission mode override for installation of shared libraries. install_override_mode=$lt_install_override_mode # Command to use after installation of a shared archive. postinstall_cmds=$lt_postinstall_cmds # Command to use after uninstallation of a shared archive. postuninstall_cmds=$lt_postuninstall_cmds # Commands used to finish a libtool library installation in a directory. finish_cmds=$lt_finish_cmds # As "finish_cmds", except a single script fragment to be evaled but # not shown. finish_eval=$lt_finish_eval # Whether we should hardcode library paths into libraries. hardcode_into_libs=$hardcode_into_libs # Compile-time system search path for libraries. sys_lib_search_path_spec=$lt_sys_lib_search_path_spec # Run-time system search path for libraries. sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec # Whether dlopen is supported. dlopen_support=$enable_dlopen # Whether dlopen of programs is supported. dlopen_self=$enable_dlopen_self # Whether dlopen of statically linked programs is supported. dlopen_self_static=$enable_dlopen_self_static # Commands to strip libraries. old_striplib=$lt_old_striplib striplib=$lt_striplib # The linker used to build libraries. LD=$lt_LD # How to create reloadable object files. reload_flag=$lt_reload_flag reload_cmds=$lt_reload_cmds # Commands used to build an old-style archive. old_archive_cmds=$lt_old_archive_cmds # A language specific compiler. CC=$lt_compiler # Is the compiler the GNU compiler? with_gcc=$GCC # Compiler flag to turn off builtin functions. no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag # Additional compiler flags for building library objects. pic_flag=$lt_lt_prog_compiler_pic # How to pass a linker flag through the compiler. wl=$lt_lt_prog_compiler_wl # Compiler flag to prevent dynamic linking. link_static_flag=$lt_lt_prog_compiler_static # Does compiler simultaneously support -c and -o options? compiler_c_o=$lt_lt_cv_prog_compiler_c_o # Whether or not to add -lc for building shared libraries. build_libtool_need_lc=$archive_cmds_need_lc # Whether or not to disallow shared libs when runtime libs are static. allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes # Compiler flag to allow reflexive dlopens. export_dynamic_flag_spec=$lt_export_dynamic_flag_spec # Compiler flag to generate shared objects directly from archives. whole_archive_flag_spec=$lt_whole_archive_flag_spec # Whether the compiler copes with passing no objects directly. compiler_needs_object=$lt_compiler_needs_object # Create an old-style archive from a shared archive. old_archive_from_new_cmds=$lt_old_archive_from_new_cmds # Create a temporary old-style archive to link instead of a shared archive. old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds # Commands used to build a shared archive. archive_cmds=$lt_archive_cmds archive_expsym_cmds=$lt_archive_expsym_cmds # Commands used to build a loadable module if different from building # a shared archive. module_cmds=$lt_module_cmds module_expsym_cmds=$lt_module_expsym_cmds # Whether we are building with GNU ld or not. with_gnu_ld=$lt_with_gnu_ld # Flag that allows shared libraries with undefined symbols to be built. allow_undefined_flag=$lt_allow_undefined_flag # Flag that enforces no undefined symbols. no_undefined_flag=$lt_no_undefined_flag # Flag to hardcode \$libdir into a binary during linking. # This must work even if \$libdir does not exist hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec # If ld is used when linking, flag to hardcode \$libdir into a binary # during linking. This must work even if \$libdir does not exist. hardcode_libdir_flag_spec_ld=$lt_hardcode_libdir_flag_spec_ld # Whether we need a single "-rpath" flag with a separated argument. hardcode_libdir_separator=$lt_hardcode_libdir_separator # Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes # DIR into the resulting binary. hardcode_direct=$hardcode_direct # Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes # DIR into the resulting binary and the resulting library dependency is # "absolute",i.e impossible to change by setting \${shlibpath_var} if the # library is relocated. hardcode_direct_absolute=$hardcode_direct_absolute # Set to "yes" if using the -LDIR flag during linking hardcodes DIR # into the resulting binary. hardcode_minus_L=$hardcode_minus_L # Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR # into the resulting binary. hardcode_shlibpath_var=$hardcode_shlibpath_var # Set to "yes" if building a shared library automatically hardcodes DIR # into the library and all subsequent libraries and executables linked # against it. hardcode_automatic=$hardcode_automatic # Set to yes if linker adds runtime paths of dependent libraries # to runtime path list. inherit_rpath=$inherit_rpath # Whether libtool must link a program against all its dependency libraries. link_all_deplibs=$link_all_deplibs # Set to "yes" if exported symbols are required. always_export_symbols=$always_export_symbols # The commands to list exported symbols. export_symbols_cmds=$lt_export_symbols_cmds # Symbols that should not be listed in the preloaded symbols. exclude_expsyms=$lt_exclude_expsyms # Symbols that must always be exported. include_expsyms=$lt_include_expsyms # Commands necessary for linking programs (against libraries) with templates. prelink_cmds=$lt_prelink_cmds # Commands necessary for finishing linking programs. postlink_cmds=$lt_postlink_cmds # Specify filename containing input files. file_list_spec=$lt_file_list_spec # How to hardcode a shared library path into an executable. hardcode_action=$hardcode_action # The directories searched by this compiler when creating a shared library. compiler_lib_search_dirs=$lt_compiler_lib_search_dirs # Dependencies to place before and after the objects being linked to # create a shared library. predep_objects=$lt_predep_objects postdep_objects=$lt_postdep_objects predeps=$lt_predeps postdeps=$lt_postdeps # The library search path used internally by the compiler when linking # a shared library. compiler_lib_search_path=$lt_compiler_lib_search_path # ### END LIBTOOL CONFIG _LT_EOF case $host_os in aix3*) cat <<\_LT_EOF >> "$cfgfile" # AIX sometimes has problems with the GCC collect2 program. For some # reason, if we set the COLLECT_NAMES environment variable, the problems # vanish in a puff of smoke. if test "X${COLLECT_NAMES+set}" != Xset; then COLLECT_NAMES= export COLLECT_NAMES fi _LT_EOF ;; esac ltmain="$ac_aux_dir/ltmain.sh" # We use sed instead of cat because bash on DJGPP gets confused if # if finds mixed CR/LF and LF-only lines. Since sed operates in # text mode, it properly converts lines to CR/LF. This bash problem # is reportedly fixed, but why not run on old versions too? sed '$q' "$ltmain" >> "$cfgfile" \ || (rm -f "$cfgfile"; exit 1) if test x"$xsi_shell" = xyes; then sed -e '/^func_dirname ()$/,/^} # func_dirname /c\ func_dirname ()\ {\ \ case ${1} in\ \ */*) func_dirname_result="${1%/*}${2}" ;;\ \ * ) func_dirname_result="${3}" ;;\ \ esac\ } # Extended-shell func_dirname implementation' "$cfgfile" > $cfgfile.tmp \ && mv -f "$cfgfile.tmp" "$cfgfile" \ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") test 0 -eq $? || _lt_function_replace_fail=: sed -e '/^func_basename ()$/,/^} # func_basename /c\ func_basename ()\ {\ \ func_basename_result="${1##*/}"\ } # Extended-shell func_basename implementation' "$cfgfile" > $cfgfile.tmp \ && mv -f "$cfgfile.tmp" "$cfgfile" \ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") test 0 -eq $? || _lt_function_replace_fail=: sed -e '/^func_dirname_and_basename ()$/,/^} # func_dirname_and_basename /c\ func_dirname_and_basename ()\ {\ \ case ${1} in\ \ */*) func_dirname_result="${1%/*}${2}" ;;\ \ * ) func_dirname_result="${3}" ;;\ \ esac\ \ func_basename_result="${1##*/}"\ } # Extended-shell func_dirname_and_basename implementation' "$cfgfile" > $cfgfile.tmp \ && mv -f "$cfgfile.tmp" "$cfgfile" \ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") test 0 -eq $? || _lt_function_replace_fail=: sed -e '/^func_stripname ()$/,/^} # func_stripname /c\ func_stripname ()\ {\ \ # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are\ \ # positional parameters, so assign one to ordinary parameter first.\ \ func_stripname_result=${3}\ \ func_stripname_result=${func_stripname_result#"${1}"}\ \ func_stripname_result=${func_stripname_result%"${2}"}\ } # Extended-shell func_stripname implementation' "$cfgfile" > $cfgfile.tmp \ && mv -f "$cfgfile.tmp" "$cfgfile" \ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") test 0 -eq $? || _lt_function_replace_fail=: sed -e '/^func_split_long_opt ()$/,/^} # func_split_long_opt /c\ func_split_long_opt ()\ {\ \ func_split_long_opt_name=${1%%=*}\ \ func_split_long_opt_arg=${1#*=}\ } # Extended-shell func_split_long_opt implementation' "$cfgfile" > $cfgfile.tmp \ && mv -f "$cfgfile.tmp" "$cfgfile" \ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") test 0 -eq $? || _lt_function_replace_fail=: sed -e '/^func_split_short_opt ()$/,/^} # func_split_short_opt /c\ func_split_short_opt ()\ {\ \ func_split_short_opt_arg=${1#??}\ \ func_split_short_opt_name=${1%"$func_split_short_opt_arg"}\ } # Extended-shell func_split_short_opt implementation' "$cfgfile" > $cfgfile.tmp \ && mv -f "$cfgfile.tmp" "$cfgfile" \ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") test 0 -eq $? || _lt_function_replace_fail=: sed -e '/^func_lo2o ()$/,/^} # func_lo2o /c\ func_lo2o ()\ {\ \ case ${1} in\ \ *.lo) func_lo2o_result=${1%.lo}.${objext} ;;\ \ *) func_lo2o_result=${1} ;;\ \ esac\ } # Extended-shell func_lo2o implementation' "$cfgfile" > $cfgfile.tmp \ && mv -f "$cfgfile.tmp" "$cfgfile" \ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") test 0 -eq $? || _lt_function_replace_fail=: sed -e '/^func_xform ()$/,/^} # func_xform /c\ func_xform ()\ {\ func_xform_result=${1%.*}.lo\ } # Extended-shell func_xform implementation' "$cfgfile" > $cfgfile.tmp \ && mv -f "$cfgfile.tmp" "$cfgfile" \ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") test 0 -eq $? || _lt_function_replace_fail=: sed -e '/^func_arith ()$/,/^} # func_arith /c\ func_arith ()\ {\ func_arith_result=$(( $* ))\ } # Extended-shell func_arith implementation' "$cfgfile" > $cfgfile.tmp \ && mv -f "$cfgfile.tmp" "$cfgfile" \ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") test 0 -eq $? || _lt_function_replace_fail=: sed -e '/^func_len ()$/,/^} # func_len /c\ func_len ()\ {\ func_len_result=${#1}\ } # Extended-shell func_len implementation' "$cfgfile" > $cfgfile.tmp \ && mv -f "$cfgfile.tmp" "$cfgfile" \ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") test 0 -eq $? || _lt_function_replace_fail=: fi if test x"$lt_shell_append" = xyes; then sed -e '/^func_append ()$/,/^} # func_append /c\ func_append ()\ {\ eval "${1}+=\\${2}"\ } # Extended-shell func_append implementation' "$cfgfile" > $cfgfile.tmp \ && mv -f "$cfgfile.tmp" "$cfgfile" \ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") test 0 -eq $? || _lt_function_replace_fail=: sed -e '/^func_append_quoted ()$/,/^} # func_append_quoted /c\ func_append_quoted ()\ {\ \ func_quote_for_eval "${2}"\ \ eval "${1}+=\\\\ \\$func_quote_for_eval_result"\ } # Extended-shell func_append_quoted implementation' "$cfgfile" > $cfgfile.tmp \ && mv -f "$cfgfile.tmp" "$cfgfile" \ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") test 0 -eq $? || _lt_function_replace_fail=: # Save a `func_append' function call where possible by direct use of '+=' sed -e 's%func_append \([a-zA-Z_]\{1,\}\) "%\1+="%g' $cfgfile > $cfgfile.tmp \ && mv -f "$cfgfile.tmp" "$cfgfile" \ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") test 0 -eq $? || _lt_function_replace_fail=: else # Save a `func_append' function call even when '+=' is not available sed -e 's%func_append \([a-zA-Z_]\{1,\}\) "%\1="$\1%g' $cfgfile > $cfgfile.tmp \ && mv -f "$cfgfile.tmp" "$cfgfile" \ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") test 0 -eq $? || _lt_function_replace_fail=: fi if test x"$_lt_function_replace_fail" = x":"; then { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Unable to substitute extended shell functions in $ofile" >&5 $as_echo "$as_me: WARNING: Unable to substitute extended shell functions in $ofile" >&2;} fi mv -f "$cfgfile" "$ofile" || (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile") chmod +x "$ofile" cat <<_LT_EOF >> "$ofile" # ### BEGIN LIBTOOL TAG CONFIG: CXX # The linker used to build libraries. LD=$lt_LD_CXX # How to create reloadable object files. reload_flag=$lt_reload_flag_CXX reload_cmds=$lt_reload_cmds_CXX # Commands used to build an old-style archive. old_archive_cmds=$lt_old_archive_cmds_CXX # A language specific compiler. CC=$lt_compiler_CXX # Is the compiler the GNU compiler? with_gcc=$GCC_CXX # Compiler flag to turn off builtin functions. no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag_CXX # Additional compiler flags for building library objects. pic_flag=$lt_lt_prog_compiler_pic_CXX # How to pass a linker flag through the compiler. wl=$lt_lt_prog_compiler_wl_CXX # Compiler flag to prevent dynamic linking. link_static_flag=$lt_lt_prog_compiler_static_CXX # Does compiler simultaneously support -c and -o options? compiler_c_o=$lt_lt_cv_prog_compiler_c_o_CXX # Whether or not to add -lc for building shared libraries. build_libtool_need_lc=$archive_cmds_need_lc_CXX # Whether or not to disallow shared libs when runtime libs are static. allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes_CXX # Compiler flag to allow reflexive dlopens. export_dynamic_flag_spec=$lt_export_dynamic_flag_spec_CXX # Compiler flag to generate shared objects directly from archives. whole_archive_flag_spec=$lt_whole_archive_flag_spec_CXX # Whether the compiler copes with passing no objects directly. compiler_needs_object=$lt_compiler_needs_object_CXX # Create an old-style archive from a shared archive. old_archive_from_new_cmds=$lt_old_archive_from_new_cmds_CXX # Create a temporary old-style archive to link instead of a shared archive. old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds_CXX # Commands used to build a shared archive. archive_cmds=$lt_archive_cmds_CXX archive_expsym_cmds=$lt_archive_expsym_cmds_CXX # Commands used to build a loadable module if different from building # a shared archive. module_cmds=$lt_module_cmds_CXX module_expsym_cmds=$lt_module_expsym_cmds_CXX # Whether we are building with GNU ld or not. with_gnu_ld=$lt_with_gnu_ld_CXX # Flag that allows shared libraries with undefined symbols to be built. allow_undefined_flag=$lt_allow_undefined_flag_CXX # Flag that enforces no undefined symbols. no_undefined_flag=$lt_no_undefined_flag_CXX # Flag to hardcode \$libdir into a binary during linking. # This must work even if \$libdir does not exist hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec_CXX # If ld is used when linking, flag to hardcode \$libdir into a binary # during linking. This must work even if \$libdir does not exist. hardcode_libdir_flag_spec_ld=$lt_hardcode_libdir_flag_spec_ld_CXX # Whether we need a single "-rpath" flag with a separated argument. hardcode_libdir_separator=$lt_hardcode_libdir_separator_CXX # Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes # DIR into the resulting binary. hardcode_direct=$hardcode_direct_CXX # Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes # DIR into the resulting binary and the resulting library dependency is # "absolute",i.e impossible to change by setting \${shlibpath_var} if the # library is relocated. hardcode_direct_absolute=$hardcode_direct_absolute_CXX # Set to "yes" if using the -LDIR flag during linking hardcodes DIR # into the resulting binary. hardcode_minus_L=$hardcode_minus_L_CXX # Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR # into the resulting binary. hardcode_shlibpath_var=$hardcode_shlibpath_var_CXX # Set to "yes" if building a shared library automatically hardcodes DIR # into the library and all subsequent libraries and executables linked # against it. hardcode_automatic=$hardcode_automatic_CXX # Set to yes if linker adds runtime paths of dependent libraries # to runtime path list. inherit_rpath=$inherit_rpath_CXX # Whether libtool must link a program against all its dependency libraries. link_all_deplibs=$link_all_deplibs_CXX # Set to "yes" if exported symbols are required. always_export_symbols=$always_export_symbols_CXX # The commands to list exported symbols. export_symbols_cmds=$lt_export_symbols_cmds_CXX # Symbols that should not be listed in the preloaded symbols. exclude_expsyms=$lt_exclude_expsyms_CXX # Symbols that must always be exported. include_expsyms=$lt_include_expsyms_CXX # Commands necessary for linking programs (against libraries) with templates. prelink_cmds=$lt_prelink_cmds_CXX # Commands necessary for finishing linking programs. postlink_cmds=$lt_postlink_cmds_CXX # Specify filename containing input files. file_list_spec=$lt_file_list_spec_CXX # How to hardcode a shared library path into an executable. hardcode_action=$hardcode_action_CXX # The directories searched by this compiler when creating a shared library. compiler_lib_search_dirs=$lt_compiler_lib_search_dirs_CXX # Dependencies to place before and after the objects being linked to # create a shared library. predep_objects=$lt_predep_objects_CXX postdep_objects=$lt_postdep_objects_CXX predeps=$lt_predeps_CXX postdeps=$lt_postdeps_CXX # The library search path used internally by the compiler when linking # a shared library. compiler_lib_search_path=$lt_compiler_lib_search_path_CXX # ### END LIBTOOL TAG CONFIG: CXX _LT_EOF ;; esac done # for ac_tag as_fn_exit 0 _ACEOF ac_clean_files=$ac_clean_files_save test $ac_write_fail = 0 || as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5 # configure is writing to config.log, and then calls config.status. # config.status does its own redirection, appending to config.log. # Unfortunately, on DOS this fails, as config.log is still kept open # by configure, so config.status won't be able to write to it; its # output is simply discarded. So we exec the FD to /dev/null, # effectively closing config.log, so it can be properly (re)opened and # appended to by config.status. When coming back to configure, we # need to make the FD available again. if test "$no_create" != yes; then ac_cs_success=: ac_config_status_args= test "$silent" = yes && ac_config_status_args="$ac_config_status_args --quiet" exec 5>/dev/null $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false exec 5>>config.log # Use ||, not &&, to avoid exiting from the if with $? = 1, which # would make configure fail if this is the last instruction. $ac_cs_success || as_fn_exit 1 fi if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;} fi mmdb-1.25.5/mmdb.pc.in0000664000175000017500000000032112151133275011312 00000000000000prefix=@prefix@ exec_prefix=@exec_prefix@ libdir=@libdir@ includedir=@includedir@ Name: mmdb Description: Macromolecular coordinate library Version: @VERSION@ Libs: -L${libdir} -lmmdb Cflags: -I${includedir} mmdb-1.25.5/config.h.in0000775000175000017500000000312111736610510011471 00000000000000/* config.h.in. Generated from configure.ac by autoheader. */ /* Define to 1 if you have the header file. */ #undef HAVE_DLFCN_H /* Define to 1 if you have the header file. */ #undef HAVE_INTTYPES_H /* Define to 1 if you have the header file. */ #undef HAVE_MEMORY_H /* Define to 1 if you have the header file. */ #undef HAVE_STDINT_H /* Define to 1 if you have the header file. */ #undef HAVE_STDLIB_H /* Define to 1 if you have the header file. */ #undef HAVE_STRINGS_H /* Define to 1 if you have the header file. */ #undef HAVE_STRING_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_STAT_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_TYPES_H /* Define to 1 if you have the header file. */ #undef HAVE_UNISTD_H /* Define to the sub-directory in which libtool stores uninstalled libraries. */ #undef LT_OBJDIR /* Name of package */ #undef PACKAGE /* Define to the address where bug reports for this package should be sent. */ #undef PACKAGE_BUGREPORT /* Define to the full name of this package. */ #undef PACKAGE_NAME /* Define to the full name and version of this package. */ #undef PACKAGE_STRING /* Define to the one symbol short name of this package. */ #undef PACKAGE_TARNAME /* Define to the home page for this package. */ #undef PACKAGE_URL /* Define to the version of this package. */ #undef PACKAGE_VERSION /* Define to 1 if you have the ANSI C header files. */ #undef STDC_HEADERS /* Version number of package */ #undef VERSION mmdb-1.25.5/Makefile.in0000664000175000017500000010634412210624040011512 00000000000000# Makefile.in generated by automake 1.12.2 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2012 Free Software Foundation, Inc. # This Makefile.in is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY, to the extent permitted by law; without # even the implied warranty of MERCHANTABILITY or FITNESS FOR A # PARTICULAR PURPOSE. @SET_MAKE@ VPATH = @srcdir@ am__make_dryrun = \ { \ am__dry=no; \ case $$MAKEFLAGS in \ *\\[\ \ ]*) \ echo 'am--echo: ; @echo "AM" OK' | $(MAKE) -f - 2>/dev/null \ | grep '^AM OK$$' >/dev/null || am__dry=yes;; \ *) \ for am__flg in $$MAKEFLAGS; do \ case $$am__flg in \ *=*|--*) ;; \ *n*) am__dry=yes; break;; \ esac; \ done;; \ esac; \ test $$am__dry = yes; \ } pkgdatadir = $(datadir)/@PACKAGE@ pkgincludedir = $(includedir)/@PACKAGE@ pkglibdir = $(libdir)/@PACKAGE@ pkglibexecdir = $(libexecdir)/@PACKAGE@ am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd install_sh_DATA = $(install_sh) -c -m 644 install_sh_PROGRAM = $(install_sh) -c install_sh_SCRIPT = $(install_sh) -c INSTALL_HEADER = $(INSTALL_DATA) transform = $(program_transform_name) NORMAL_INSTALL = : PRE_INSTALL = : POST_INSTALL = : NORMAL_UNINSTALL = : PRE_UNINSTALL = : POST_UNINSTALL = : build_triplet = @build@ host_triplet = @host@ subdir = . DIST_COMMON = README $(am__configure_deps) $(pkginclude_HEADERS) \ $(srcdir)/Makefile.am $(srcdir)/Makefile.in \ $(srcdir)/config.h.in $(srcdir)/mmdb.pc.in \ $(top_srcdir)/build-aux/ar-lib \ $(top_srcdir)/build-aux/config.guess \ $(top_srcdir)/build-aux/config.sub \ $(top_srcdir)/build-aux/depcomp \ $(top_srcdir)/build-aux/install-sh \ $(top_srcdir)/build-aux/ltmain.sh \ $(top_srcdir)/build-aux/missing $(top_srcdir)/configure \ AUTHORS COPYING COPYING.LESSER INSTALL build-aux/ar-lib \ build-aux/config.guess build-aux/config.sub build-aux/depcomp \ build-aux/install-sh build-aux/ltmain.sh build-aux/missing ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/libtool.m4 \ $(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \ $(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \ $(top_srcdir)/configure.ac am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ $(ACLOCAL_M4) am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \ configure.lineno config.status.lineno mkinstalldirs = $(install_sh) -d CONFIG_HEADER = config.h CONFIG_CLEAN_FILES = mmdb.pc CONFIG_CLEAN_VPATH_FILES = am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; am__vpath_adj = case $$p in \ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ *) f=$$p;; \ esac; am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; am__install_max = 40 am__nobase_strip_setup = \ srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` am__nobase_strip = \ for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" am__nobase_list = $(am__nobase_strip_setup); \ for p in $$list; do echo "$$p $$p"; done | \ sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ if (++n[$$2] == $(am__install_max)) \ { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ END { for (dir in files) print dir, files[dir] }' am__base_list = \ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' am__uninstall_files_from_dir = { \ test -z "$$files" \ || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ $(am__cd) "$$dir" && rm -f $$files; }; \ } am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(pkgconfigdir)" \ "$(DESTDIR)$(pkgincludedir)" LTLIBRARIES = $(lib_LTLIBRARIES) mmdb_libmmdb_la_LIBADD = am__dirstamp = $(am__leading_dot)dirstamp am_mmdb_libmmdb_la_OBJECTS = mmdb/bfgs_min.lo mmdb/mmdb_bondmngr.lo \ mmdb/mmdb_manager.lo mmdb/mmdb_symop.lo mmdb/file_.lo \ mmdb/mmdb_chain.lo mmdb/mmdb_mask.lo mmdb/mmdb_tables.lo \ mmdb/linalg_.lo mmdb/mmdb_cifdefs.lo mmdb/mmdb_mmcif.lo \ mmdb/mmdb_title.lo mmdb/machine_.lo mmdb/mmdb_coormngr.lo \ mmdb/mmdb_model.lo mmdb/mmdb_uddata.lo mmdb/math_.lo \ mmdb/mmdb_cryst.lo mmdb/mmdb_rwbrook.lo mmdb/mmdb_utils.lo \ mmdb/mattype_.lo mmdb/mmdb_ficif.lo mmdb/mmdb_sbase0.lo \ mmdb/mmdb_xml.lo mmdb/mmdb_align.lo mmdb/mmdb_file.lo \ mmdb/mmdb_sbase.lo mmdb/random_n.lo mmdb/mmdb_atom.lo \ mmdb/mmdb_graph.lo mmdb/mmdb_selmngr.lo mmdb/stream_.lo \ mmdb/hybrid_36.lo mmdb_libmmdb_la_OBJECTS = $(am_mmdb_libmmdb_la_OBJECTS) AM_V_lt = $(am__v_lt_@AM_V@) am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@) am__v_lt_0 = --silent am__v_lt_1 = mmdb_libmmdb_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \ $(AM_CXXFLAGS) $(CXXFLAGS) $(mmdb_libmmdb_la_LDFLAGS) \ $(LDFLAGS) -o $@ AM_V_P = $(am__v_P_@AM_V@) am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) am__v_P_0 = false am__v_P_1 = : AM_V_GEN = $(am__v_GEN_@AM_V@) am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) am__v_GEN_0 = @echo " GEN " $@; am__v_GEN_1 = AM_V_at = $(am__v_at_@AM_V@) am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) am__v_at_0 = @ am__v_at_1 = DEFAULT_INCLUDES = -I.@am__isrc@ depcomp = $(SHELL) $(top_srcdir)/build-aux/depcomp am__depfiles_maybe = depfiles am__mv = mv -f CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \ $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ $(AM_CXXFLAGS) $(CXXFLAGS) AM_V_CXX = $(am__v_CXX_@AM_V@) am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@) am__v_CXX_0 = @echo " CXX " $@; am__v_CXX_1 = CXXLD = $(CXX) CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@ AM_V_CXXLD = $(am__v_CXXLD_@AM_V@) am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@) am__v_CXXLD_0 = @echo " CXXLD " $@; am__v_CXXLD_1 = SOURCES = $(mmdb_libmmdb_la_SOURCES) DIST_SOURCES = $(mmdb_libmmdb_la_SOURCES) am__can_run_installinfo = \ case $$AM_UPDATE_INFO_DIR in \ n|no|NO) false;; \ *) (install-info --version) >/dev/null 2>&1;; \ esac DATA = $(pkgconfig_DATA) HEADERS = $(pkginclude_HEADERS) ETAGS = etags CTAGS = ctags CSCOPE = cscope AM_RECURSIVE_TARGETS = cscope DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) distdir = $(PACKAGE)-$(VERSION) top_distdir = $(distdir) am__remove_distdir = \ if test -d "$(distdir)"; then \ find "$(distdir)" -type d ! -perm -200 -exec chmod u+w {} ';' \ && rm -rf "$(distdir)" \ || { sleep 5 && rm -rf "$(distdir)"; }; \ else :; fi am__post_remove_distdir = $(am__remove_distdir) DIST_ARCHIVES = $(distdir).tar.gz GZIP_ENV = --best DIST_TARGETS = dist-gzip distuninstallcheck_listfiles = find . -type f -print am__distuninstallcheck_listfiles = $(distuninstallcheck_listfiles) \ | sed 's|^\./|$(prefix)/|' | grep -v '$(infodir)/dir$$' distcleancheck_listfiles = find . -type f -print ACLOCAL = @ACLOCAL@ AMTAR = @AMTAR@ AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ AR = @AR@ AS = @AS@ AUTOCONF = @AUTOCONF@ AUTOHEADER = @AUTOHEADER@ AUTOMAKE = @AUTOMAKE@ AWK = @AWK@ CC = @CC@ CCDEPMODE = @CCDEPMODE@ CFLAGS = @CFLAGS@ CPP = @CPP@ CPPFLAGS = @CPPFLAGS@ CXX = @CXX@ CXXCPP = @CXXCPP@ CXXDEPMODE = @CXXDEPMODE@ CXXFLAGS = @CXXFLAGS@ CYGPATH_W = @CYGPATH_W@ DEFS = @DEFS@ DEPDIR = @DEPDIR@ DLLTOOL = @DLLTOOL@ DSYMUTIL = @DSYMUTIL@ DUMPBIN = @DUMPBIN@ ECHO_C = @ECHO_C@ ECHO_N = @ECHO_N@ ECHO_T = @ECHO_T@ EGREP = @EGREP@ EXEEXT = @EXEEXT@ FGREP = @FGREP@ GREP = @GREP@ INSTALL = @INSTALL@ INSTALL_DATA = @INSTALL_DATA@ INSTALL_PROGRAM = @INSTALL_PROGRAM@ INSTALL_SCRIPT = @INSTALL_SCRIPT@ INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ LD = @LD@ LDFLAGS = @LDFLAGS@ LIBOBJS = @LIBOBJS@ LIBS = @LIBS@ LIBTOOL = @LIBTOOL@ LIPO = @LIPO@ LN_S = @LN_S@ LTLIBOBJS = @LTLIBOBJS@ MAINT = @MAINT@ MAKEINFO = @MAKEINFO@ MANIFEST_TOOL = @MANIFEST_TOOL@ MKDIR_P = @MKDIR_P@ NM = @NM@ NMEDIT = @NMEDIT@ OBJDUMP = @OBJDUMP@ OBJEXT = @OBJEXT@ OTOOL = @OTOOL@ OTOOL64 = @OTOOL64@ PACKAGE = @PACKAGE@ PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ PACKAGE_NAME = @PACKAGE_NAME@ PACKAGE_STRING = @PACKAGE_STRING@ PACKAGE_TARNAME = @PACKAGE_TARNAME@ PACKAGE_URL = @PACKAGE_URL@ PACKAGE_VERSION = @PACKAGE_VERSION@ PATH_SEPARATOR = @PATH_SEPARATOR@ RANLIB = @RANLIB@ SED = @SED@ SET_MAKE = @SET_MAKE@ SHELL = @SHELL@ STRIP = @STRIP@ VERSION = @VERSION@ abs_builddir = @abs_builddir@ abs_srcdir = @abs_srcdir@ abs_top_builddir = @abs_top_builddir@ abs_top_srcdir = @abs_top_srcdir@ ac_ct_AR = @ac_ct_AR@ ac_ct_CC = @ac_ct_CC@ ac_ct_CXX = @ac_ct_CXX@ ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ am__include = @am__include@ am__leading_dot = @am__leading_dot@ am__quote = @am__quote@ am__tar = @am__tar@ am__untar = @am__untar@ bindir = @bindir@ build = @build@ build_alias = @build_alias@ build_cpu = @build_cpu@ build_os = @build_os@ build_vendor = @build_vendor@ builddir = @builddir@ datadir = @datadir@ datarootdir = @datarootdir@ docdir = @docdir@ dvidir = @dvidir@ exec_prefix = @exec_prefix@ host = @host@ host_alias = @host_alias@ host_cpu = @host_cpu@ host_os = @host_os@ host_vendor = @host_vendor@ htmldir = @htmldir@ includedir = @includedir@ infodir = @infodir@ install_sh = @install_sh@ libdir = @libdir@ libexecdir = @libexecdir@ localedir = @localedir@ localstatedir = @localstatedir@ mandir = @mandir@ mkdir_p = @mkdir_p@ oldincludedir = @oldincludedir@ pdfdir = @pdfdir@ prefix = @prefix@ program_transform_name = @program_transform_name@ psdir = @psdir@ sbindir = @sbindir@ sharedstatedir = @sharedstatedir@ srcdir = @srcdir@ sysconfdir = @sysconfdir@ target_alias = @target_alias@ top_build_prefix = @top_build_prefix@ top_builddir = @top_builddir@ top_srcdir = @top_srcdir@ ACLOCAL_AMFLAGS = -I m4 lib_LTLIBRARIES = mmdb/libmmdb.la pkginclude_HEADERS = \ mmdb/bfgs_min.h mmdb/mmdb_atom.h mmdb/mmdb_ficif.h \ mmdb/mmdb_rwbrook.h mmdb/mmdb_uddata.h mmdb/file_.h \ mmdb/mmdb_bondmngr.h mmdb/mmdb_file.h mmdb/mmdb_sbase0.h \ mmdb/mmdb_utils.h mmdb/linalg_.h mmdb/mmdb_chain.h \ mmdb/mmdb_graph.h mmdb/mmdb_sbase.h mmdb/mmdb_xml.h \ mmdb/machine_.h mmdb/mmdb_cifdefs.h mmdb/mmdb_manager.h \ mmdb/mmdb_selmngr.h mmdb/random_n.h mmdb/math_.h \ mmdb/mmdb_coormngr.h mmdb/mmdb_mask.h mmdb/mmdb_symop.h \ mmdb/stream_.h mmdb/mattype_.h mmdb/mmdb_cryst.h \ mmdb/mmdb_mmcif.h mmdb/mmdb_tables.h mmdb/mmdb_align.h \ mmdb/mmdb_defs.h mmdb/mmdb_model.h mmdb/mmdb_title.h \ mmdb/hybrid_36.h mmdb_libmmdb_la_SOURCES = \ mmdb/bfgs_min.cpp mmdb/mmdb_bondmngr.cpp mmdb/mmdb_manager.cpp \ mmdb/mmdb_symop.cpp mmdb/file_.cpp mmdb/mmdb_chain.cpp \ mmdb/mmdb_mask.cpp mmdb/mmdb_tables.cpp mmdb/linalg_.cpp \ mmdb/mmdb_cifdefs.cpp mmdb/mmdb_mmcif.cpp mmdb/mmdb_title.cpp \ mmdb/machine_.cpp mmdb/mmdb_coormngr.cpp mmdb/mmdb_model.cpp \ mmdb/mmdb_uddata.cpp mmdb/math_.cpp mmdb/mmdb_cryst.cpp \ mmdb/mmdb_rwbrook.cpp mmdb/mmdb_utils.cpp mmdb/mattype_.cpp \ mmdb/mmdb_ficif.cpp mmdb/mmdb_sbase0.cpp mmdb/mmdb_xml.cpp \ mmdb/mmdb_align.cpp mmdb/mmdb_file.cpp mmdb/mmdb_sbase.cpp \ mmdb/random_n.cpp mmdb/mmdb_atom.cpp mmdb/mmdb_graph.cpp \ mmdb/mmdb_selmngr.cpp mmdb/stream_.cpp mmdb/hybrid_36.cpp mmdb_libmmdb_la_LDFLAGS = -no-undefined pkgconfigdir = $(libdir)/pkgconfig pkgconfig_DATA = mmdb.pc all: config.h $(MAKE) $(AM_MAKEFLAGS) all-am .SUFFIXES: .SUFFIXES: .cpp .lo .o .obj am--refresh: Makefile @: $(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(am__configure_deps) @for dep in $?; do \ case '$(am__configure_deps)' in \ *$$dep*) \ echo ' cd $(srcdir) && $(AUTOMAKE) --foreign'; \ $(am__cd) $(srcdir) && $(AUTOMAKE) --foreign \ && exit 0; \ exit 1;; \ esac; \ done; \ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign Makefile'; \ $(am__cd) $(top_srcdir) && \ $(AUTOMAKE) --foreign Makefile .PRECIOUS: Makefile Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status @case '$?' in \ *config.status*) \ echo ' $(SHELL) ./config.status'; \ $(SHELL) ./config.status;; \ *) \ echo ' cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe)'; \ cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe);; \ esac; $(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) $(SHELL) ./config.status --recheck $(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps) $(am__cd) $(srcdir) && $(AUTOCONF) $(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps) $(am__cd) $(srcdir) && $(ACLOCAL) $(ACLOCAL_AMFLAGS) $(am__aclocal_m4_deps): config.h: stamp-h1 @if test ! -f $@; then rm -f stamp-h1; else :; fi @if test ! -f $@; then $(MAKE) $(AM_MAKEFLAGS) stamp-h1; else :; fi stamp-h1: $(srcdir)/config.h.in $(top_builddir)/config.status @rm -f stamp-h1 cd $(top_builddir) && $(SHELL) ./config.status config.h $(srcdir)/config.h.in: @MAINTAINER_MODE_TRUE@ $(am__configure_deps) ($(am__cd) $(top_srcdir) && $(AUTOHEADER)) rm -f stamp-h1 touch $@ distclean-hdr: -rm -f config.h stamp-h1 mmdb.pc: $(top_builddir)/config.status $(srcdir)/mmdb.pc.in cd $(top_builddir) && $(SHELL) ./config.status $@ install-libLTLIBRARIES: $(lib_LTLIBRARIES) @$(NORMAL_INSTALL) @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ list2=; for p in $$list; do \ if test -f $$p; then \ list2="$$list2 $$p"; \ else :; fi; \ done; \ test -z "$$list2" || { \ echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \ $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \ } uninstall-libLTLIBRARIES: @$(NORMAL_UNINSTALL) @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ for p in $$list; do \ $(am__strip_dir) \ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \ done clean-libLTLIBRARIES: -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES) @list='$(lib_LTLIBRARIES)'; \ locs=`for p in $$list; do echo $$p; done | \ sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \ sort -u`; \ test -z "$$locs" || { \ echo rm -f $${locs}; \ rm -f $${locs}; \ } mmdb/$(am__dirstamp): @$(MKDIR_P) mmdb @: > mmdb/$(am__dirstamp) mmdb/$(DEPDIR)/$(am__dirstamp): @$(MKDIR_P) mmdb/$(DEPDIR) @: > mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/bfgs_min.lo: mmdb/$(am__dirstamp) mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/mmdb_bondmngr.lo: mmdb/$(am__dirstamp) \ mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/mmdb_manager.lo: mmdb/$(am__dirstamp) \ mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/mmdb_symop.lo: mmdb/$(am__dirstamp) \ mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/file_.lo: mmdb/$(am__dirstamp) mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/mmdb_chain.lo: mmdb/$(am__dirstamp) \ mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/mmdb_mask.lo: mmdb/$(am__dirstamp) mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/mmdb_tables.lo: mmdb/$(am__dirstamp) \ mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/linalg_.lo: mmdb/$(am__dirstamp) mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/mmdb_cifdefs.lo: mmdb/$(am__dirstamp) \ mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/mmdb_mmcif.lo: mmdb/$(am__dirstamp) \ mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/mmdb_title.lo: mmdb/$(am__dirstamp) \ mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/machine_.lo: mmdb/$(am__dirstamp) mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/mmdb_coormngr.lo: mmdb/$(am__dirstamp) \ mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/mmdb_model.lo: mmdb/$(am__dirstamp) \ mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/mmdb_uddata.lo: mmdb/$(am__dirstamp) \ mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/math_.lo: mmdb/$(am__dirstamp) mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/mmdb_cryst.lo: mmdb/$(am__dirstamp) \ mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/mmdb_rwbrook.lo: mmdb/$(am__dirstamp) \ mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/mmdb_utils.lo: mmdb/$(am__dirstamp) \ mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/mattype_.lo: mmdb/$(am__dirstamp) mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/mmdb_ficif.lo: mmdb/$(am__dirstamp) \ mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/mmdb_sbase0.lo: mmdb/$(am__dirstamp) \ mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/mmdb_xml.lo: mmdb/$(am__dirstamp) mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/mmdb_align.lo: mmdb/$(am__dirstamp) \ mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/mmdb_file.lo: mmdb/$(am__dirstamp) mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/mmdb_sbase.lo: mmdb/$(am__dirstamp) \ mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/random_n.lo: mmdb/$(am__dirstamp) mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/mmdb_atom.lo: mmdb/$(am__dirstamp) mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/mmdb_graph.lo: mmdb/$(am__dirstamp) \ mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/mmdb_selmngr.lo: mmdb/$(am__dirstamp) \ mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/stream_.lo: mmdb/$(am__dirstamp) mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/hybrid_36.lo: mmdb/$(am__dirstamp) mmdb/$(DEPDIR)/$(am__dirstamp) mmdb/libmmdb.la: $(mmdb_libmmdb_la_OBJECTS) $(mmdb_libmmdb_la_DEPENDENCIES) $(EXTRA_mmdb_libmmdb_la_DEPENDENCIES) mmdb/$(am__dirstamp) $(AM_V_CXXLD)$(mmdb_libmmdb_la_LINK) -rpath $(libdir) $(mmdb_libmmdb_la_OBJECTS) $(mmdb_libmmdb_la_LIBADD) $(LIBS) mostlyclean-compile: -rm -f *.$(OBJEXT) -rm -f mmdb/*.$(OBJEXT) -rm -f mmdb/*.lo distclean-compile: -rm -f *.tab.c @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/bfgs_min.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/file_.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/hybrid_36.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/linalg_.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/machine_.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/math_.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/mattype_.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/mmdb_align.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/mmdb_atom.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/mmdb_bondmngr.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/mmdb_chain.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/mmdb_cifdefs.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/mmdb_coormngr.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/mmdb_cryst.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/mmdb_ficif.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/mmdb_file.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/mmdb_graph.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/mmdb_manager.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/mmdb_mask.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/mmdb_mmcif.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/mmdb_model.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/mmdb_rwbrook.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/mmdb_sbase.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/mmdb_sbase0.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/mmdb_selmngr.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/mmdb_symop.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/mmdb_tables.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/mmdb_title.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/mmdb_uddata.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/mmdb_utils.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/mmdb_xml.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/random_n.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@mmdb/$(DEPDIR)/stream_.Plo@am__quote@ .cpp.o: @am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\ @am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ @am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po @AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $< .cpp.obj: @am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\ @am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\ @am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po @AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` .cpp.lo: @am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\ @am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ @am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo @AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $< mostlyclean-libtool: -rm -f *.lo clean-libtool: -rm -rf .libs _libs -rm -rf mmdb/.libs mmdb/_libs distclean-libtool: -rm -f libtool config.lt install-pkgconfigDATA: $(pkgconfig_DATA) @$(NORMAL_INSTALL) @list='$(pkgconfig_DATA)'; test -n "$(pkgconfigdir)" || list=; \ if test -n "$$list"; then \ echo " $(MKDIR_P) '$(DESTDIR)$(pkgconfigdir)'"; \ $(MKDIR_P) "$(DESTDIR)$(pkgconfigdir)" || exit 1; \ fi; \ for p in $$list; do \ if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ echo "$$d$$p"; \ done | $(am__base_list) | \ while read files; do \ echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(pkgconfigdir)'"; \ $(INSTALL_DATA) $$files "$(DESTDIR)$(pkgconfigdir)" || exit $$?; \ done uninstall-pkgconfigDATA: @$(NORMAL_UNINSTALL) @list='$(pkgconfig_DATA)'; test -n "$(pkgconfigdir)" || list=; \ files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ dir='$(DESTDIR)$(pkgconfigdir)'; $(am__uninstall_files_from_dir) install-pkgincludeHEADERS: $(pkginclude_HEADERS) @$(NORMAL_INSTALL) @list='$(pkginclude_HEADERS)'; test -n "$(pkgincludedir)" || list=; \ if test -n "$$list"; then \ echo " $(MKDIR_P) '$(DESTDIR)$(pkgincludedir)'"; \ $(MKDIR_P) "$(DESTDIR)$(pkgincludedir)" || exit 1; \ fi; \ for p in $$list; do \ if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ echo "$$d$$p"; \ done | $(am__base_list) | \ while read files; do \ echo " $(INSTALL_HEADER) $$files '$(DESTDIR)$(pkgincludedir)'"; \ $(INSTALL_HEADER) $$files "$(DESTDIR)$(pkgincludedir)" || exit $$?; \ done uninstall-pkgincludeHEADERS: @$(NORMAL_UNINSTALL) @list='$(pkginclude_HEADERS)'; test -n "$(pkgincludedir)" || list=; \ files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ dir='$(DESTDIR)$(pkgincludedir)'; $(am__uninstall_files_from_dir) ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES) list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ unique=`for i in $$list; do \ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ done | \ $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ END { if (nonempty) { for (i in files) print i; }; }'`; \ mkid -fID $$unique tags: TAGS TAGS: $(HEADERS) $(SOURCES) config.h.in $(TAGS_DEPENDENCIES) \ $(TAGS_FILES) $(LISP) set x; \ here=`pwd`; \ list='$(SOURCES) $(HEADERS) config.h.in $(LISP) $(TAGS_FILES)'; \ unique=`for i in $$list; do \ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ done | \ $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ END { if (nonempty) { for (i in files) print i; }; }'`; \ shift; \ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ test -n "$$unique" || unique=$$empty_fix; \ if test $$# -gt 0; then \ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ "$$@" $$unique; \ else \ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ $$unique; \ fi; \ fi ctags: CTAGS CTAGS: $(HEADERS) $(SOURCES) config.h.in $(TAGS_DEPENDENCIES) \ $(TAGS_FILES) $(LISP) list='$(SOURCES) $(HEADERS) config.h.in $(LISP) $(TAGS_FILES)'; \ unique=`for i in $$list; do \ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ done | \ $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ END { if (nonempty) { for (i in files) print i; }; }'`; \ test -z "$(CTAGS_ARGS)$$unique" \ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ $$unique GTAGS: here=`$(am__cd) $(top_builddir) && pwd` \ && $(am__cd) $(top_srcdir) \ && gtags -i $(GTAGS_ARGS) "$$here" cscope: cscope.files test ! -s cscope.files \ || $(CSCOPE) -b -q $(AM_CSCOPEFLAGS) $(CSCOPEFLAGS) -i cscope.files $(CSCOPE_ARGS) clean-cscope: -rm -f cscope.files cscope.files: clean-cscope cscopelist cscopelist: $(HEADERS) $(SOURCES) $(LISP) list='$(SOURCES) $(HEADERS) $(LISP)'; \ case "$(srcdir)" in \ [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ *) sdir=$(subdir)/$(srcdir) ;; \ esac; \ for i in $$list; do \ if test -f "$$i"; then \ echo "$(subdir)/$$i"; \ else \ echo "$$sdir/$$i"; \ fi; \ done >> $(top_builddir)/cscope.files distclean-tags: -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags -rm -f cscope.out cscope.in.out cscope.po.out cscope.files distdir: $(DISTFILES) $(am__remove_distdir) test -d "$(distdir)" || mkdir "$(distdir)" @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ list='$(DISTFILES)'; \ dist_files=`for file in $$list; do echo $$file; done | \ sed -e "s|^$$srcdirstrip/||;t" \ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ case $$dist_files in \ */*) $(MKDIR_P) `echo "$$dist_files" | \ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ sort -u` ;; \ esac; \ for file in $$dist_files; do \ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ if test -d $$d/$$file; then \ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ if test -d "$(distdir)/$$file"; then \ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ fi; \ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ fi; \ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ else \ test -f "$(distdir)/$$file" \ || cp -p $$d/$$file "$(distdir)/$$file" \ || exit 1; \ fi; \ done -test -n "$(am__skip_mode_fix)" \ || find "$(distdir)" -type d ! -perm -755 \ -exec chmod u+rwx,go+rx {} \; -o \ ! -type d ! -perm -444 -links 1 -exec chmod a+r {} \; -o \ ! -type d ! -perm -400 -exec chmod a+r {} \; -o \ ! -type d ! -perm -444 -exec $(install_sh) -c -m a+r {} {} \; \ || chmod -R a+r "$(distdir)" dist-gzip: distdir tardir=$(distdir) && $(am__tar) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz $(am__post_remove_distdir) dist-bzip2: distdir tardir=$(distdir) && $(am__tar) | BZIP2=$${BZIP2--9} bzip2 -c >$(distdir).tar.bz2 $(am__post_remove_distdir) dist-lzip: distdir tardir=$(distdir) && $(am__tar) | lzip -c $${LZIP_OPT--9} >$(distdir).tar.lz $(am__post_remove_distdir) dist-xz: distdir tardir=$(distdir) && $(am__tar) | XZ_OPT=$${XZ_OPT--e} xz -c >$(distdir).tar.xz $(am__post_remove_distdir) dist-tarZ: distdir tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z $(am__post_remove_distdir) dist-shar: distdir shar $(distdir) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).shar.gz $(am__post_remove_distdir) dist-zip: distdir -rm -f $(distdir).zip zip -rq $(distdir).zip $(distdir) $(am__post_remove_distdir) dist dist-all: $(MAKE) $(AM_MAKEFLAGS) $(DIST_TARGETS) am__post_remove_distdir='@:' $(am__post_remove_distdir) # This target untars the dist file and tries a VPATH configuration. Then # it guarantees that the distribution is self-contained by making another # tarfile. distcheck: dist case '$(DIST_ARCHIVES)' in \ *.tar.gz*) \ GZIP=$(GZIP_ENV) gzip -dc $(distdir).tar.gz | $(am__untar) ;;\ *.tar.bz2*) \ bzip2 -dc $(distdir).tar.bz2 | $(am__untar) ;;\ *.tar.lz*) \ lzip -dc $(distdir).tar.lz | $(am__untar) ;;\ *.tar.xz*) \ xz -dc $(distdir).tar.xz | $(am__untar) ;;\ *.tar.Z*) \ uncompress -c $(distdir).tar.Z | $(am__untar) ;;\ *.shar.gz*) \ GZIP=$(GZIP_ENV) gzip -dc $(distdir).shar.gz | unshar ;;\ *.zip*) \ unzip $(distdir).zip ;;\ esac chmod -R a-w $(distdir); chmod u+w $(distdir) mkdir $(distdir)/_build mkdir $(distdir)/_inst chmod a-w $(distdir) test -d $(distdir)/_build || exit 0; \ dc_install_base=`$(am__cd) $(distdir)/_inst && pwd | sed -e 's,^[^:\\/]:[\\/],/,'` \ && dc_destdir="$${TMPDIR-/tmp}/am-dc-$$$$/" \ && am__cwd=`pwd` \ && $(am__cd) $(distdir)/_build \ && ../configure --srcdir=.. --prefix="$$dc_install_base" \ $(AM_DISTCHECK_CONFIGURE_FLAGS) \ $(DISTCHECK_CONFIGURE_FLAGS) \ && $(MAKE) $(AM_MAKEFLAGS) \ && $(MAKE) $(AM_MAKEFLAGS) dvi \ && $(MAKE) $(AM_MAKEFLAGS) check \ && $(MAKE) $(AM_MAKEFLAGS) install \ && $(MAKE) $(AM_MAKEFLAGS) installcheck \ && $(MAKE) $(AM_MAKEFLAGS) uninstall \ && $(MAKE) $(AM_MAKEFLAGS) distuninstallcheck_dir="$$dc_install_base" \ distuninstallcheck \ && chmod -R a-w "$$dc_install_base" \ && ({ \ (cd ../.. && umask 077 && mkdir "$$dc_destdir") \ && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" install \ && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" uninstall \ && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" \ distuninstallcheck_dir="$$dc_destdir" distuninstallcheck; \ } || { rm -rf "$$dc_destdir"; exit 1; }) \ && rm -rf "$$dc_destdir" \ && $(MAKE) $(AM_MAKEFLAGS) dist \ && rm -rf $(DIST_ARCHIVES) \ && $(MAKE) $(AM_MAKEFLAGS) distcleancheck \ && cd "$$am__cwd" \ || exit 1 $(am__post_remove_distdir) @(echo "$(distdir) archives ready for distribution: "; \ list='$(DIST_ARCHIVES)'; for i in $$list; do echo $$i; done) | \ sed -e 1h -e 1s/./=/g -e 1p -e 1x -e '$$p' -e '$$x' distuninstallcheck: @test -n '$(distuninstallcheck_dir)' || { \ echo 'ERROR: trying to run $@ with an empty' \ '$$(distuninstallcheck_dir)' >&2; \ exit 1; \ }; \ $(am__cd) '$(distuninstallcheck_dir)' || { \ echo 'ERROR: cannot chdir into $(distuninstallcheck_dir)' >&2; \ exit 1; \ }; \ test `$(am__distuninstallcheck_listfiles) | wc -l` -eq 0 \ || { echo "ERROR: files left after uninstall:" ; \ if test -n "$(DESTDIR)"; then \ echo " (check DESTDIR support)"; \ fi ; \ $(distuninstallcheck_listfiles) ; \ exit 1; } >&2 distcleancheck: distclean @if test '$(srcdir)' = . ; then \ echo "ERROR: distcleancheck can only run from a VPATH build" ; \ exit 1 ; \ fi @test `$(distcleancheck_listfiles) | wc -l` -eq 0 \ || { echo "ERROR: files left in build directory after distclean:" ; \ $(distcleancheck_listfiles) ; \ exit 1; } >&2 check-am: all-am check: check-am all-am: Makefile $(LTLIBRARIES) $(DATA) $(HEADERS) config.h installdirs: for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(pkgconfigdir)" "$(DESTDIR)$(pkgincludedir)"; do \ test -z "$$dir" || $(MKDIR_P) "$$dir"; \ done install: install-am install-exec: install-exec-am install-data: install-data-am uninstall: uninstall-am install-am: all-am @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am installcheck: installcheck-am install-strip: if test -z '$(STRIP)'; then \ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ install; \ else \ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ fi mostlyclean-generic: clean-generic: distclean-generic: -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) -rm -f mmdb/$(DEPDIR)/$(am__dirstamp) -rm -f mmdb/$(am__dirstamp) maintainer-clean-generic: @echo "This command is intended for maintainers to use" @echo "it deletes files that may require special tools to rebuild." clean: clean-am clean-am: clean-generic clean-libLTLIBRARIES clean-libtool \ mostlyclean-am distclean: distclean-am -rm -f $(am__CONFIG_DISTCLEAN_FILES) -rm -rf mmdb/$(DEPDIR) -rm -f Makefile distclean-am: clean-am distclean-compile distclean-generic \ distclean-hdr distclean-libtool distclean-tags dvi: dvi-am dvi-am: html: html-am html-am: info: info-am info-am: install-data-am: install-pkgconfigDATA install-pkgincludeHEADERS install-dvi: install-dvi-am install-dvi-am: install-exec-am: install-libLTLIBRARIES install-html: install-html-am install-html-am: install-info: install-info-am install-info-am: install-man: install-pdf: install-pdf-am install-pdf-am: install-ps: install-ps-am install-ps-am: installcheck-am: maintainer-clean: maintainer-clean-am -rm -f $(am__CONFIG_DISTCLEAN_FILES) -rm -rf $(top_srcdir)/autom4te.cache -rm -rf mmdb/$(DEPDIR) -rm -f Makefile maintainer-clean-am: distclean-am maintainer-clean-generic mostlyclean: mostlyclean-am mostlyclean-am: mostlyclean-compile mostlyclean-generic \ mostlyclean-libtool pdf: pdf-am pdf-am: ps: ps-am ps-am: uninstall-am: uninstall-libLTLIBRARIES uninstall-pkgconfigDATA \ uninstall-pkgincludeHEADERS .MAKE: all install-am install-strip .PHONY: CTAGS GTAGS all all-am am--refresh check check-am clean \ clean-cscope clean-generic clean-libLTLIBRARIES clean-libtool \ cscope cscopelist ctags dist dist-all dist-bzip2 dist-gzip \ dist-lzip dist-shar dist-tarZ dist-xz dist-zip distcheck \ distclean distclean-compile distclean-generic distclean-hdr \ distclean-libtool distclean-tags distcleancheck distdir \ distuninstallcheck dvi dvi-am html html-am info info-am \ install install-am install-data install-data-am install-dvi \ install-dvi-am install-exec install-exec-am install-html \ install-html-am install-info install-info-am \ install-libLTLIBRARIES install-man install-pdf install-pdf-am \ install-pkgconfigDATA install-pkgincludeHEADERS install-ps \ install-ps-am install-strip installcheck installcheck-am \ installdirs maintainer-clean maintainer-clean-generic \ mostlyclean mostlyclean-compile mostlyclean-generic \ mostlyclean-libtool pdf pdf-am ps ps-am tags uninstall \ uninstall-am uninstall-libLTLIBRARIES uninstall-pkgconfigDATA \ uninstall-pkgincludeHEADERS # Tell versions [3.59,3.63) of GNU make to not export all variables. # Otherwise a system limit (for SysV at least) may be exceeded. .NOEXPORT: mmdb-1.25.5/Makefile.am0000664000175000017500000000330512151134006011474 00000000000000 ACLOCAL_AMFLAGS = -I m4 lib_LTLIBRARIES = mmdb/libmmdb.la pkginclude_HEADERS = \ mmdb/bfgs_min.h mmdb/mmdb_atom.h mmdb/mmdb_ficif.h \ mmdb/mmdb_rwbrook.h mmdb/mmdb_uddata.h mmdb/file_.h \ mmdb/mmdb_bondmngr.h mmdb/mmdb_file.h mmdb/mmdb_sbase0.h \ mmdb/mmdb_utils.h mmdb/linalg_.h mmdb/mmdb_chain.h \ mmdb/mmdb_graph.h mmdb/mmdb_sbase.h mmdb/mmdb_xml.h \ mmdb/machine_.h mmdb/mmdb_cifdefs.h mmdb/mmdb_manager.h \ mmdb/mmdb_selmngr.h mmdb/random_n.h mmdb/math_.h \ mmdb/mmdb_coormngr.h mmdb/mmdb_mask.h mmdb/mmdb_symop.h \ mmdb/stream_.h mmdb/mattype_.h mmdb/mmdb_cryst.h \ mmdb/mmdb_mmcif.h mmdb/mmdb_tables.h mmdb/mmdb_align.h \ mmdb/mmdb_defs.h mmdb/mmdb_model.h mmdb/mmdb_title.h \ mmdb/hybrid_36.h mmdb_libmmdb_la_SOURCES = \ mmdb/bfgs_min.cpp mmdb/mmdb_bondmngr.cpp mmdb/mmdb_manager.cpp \ mmdb/mmdb_symop.cpp mmdb/file_.cpp mmdb/mmdb_chain.cpp \ mmdb/mmdb_mask.cpp mmdb/mmdb_tables.cpp mmdb/linalg_.cpp \ mmdb/mmdb_cifdefs.cpp mmdb/mmdb_mmcif.cpp mmdb/mmdb_title.cpp \ mmdb/machine_.cpp mmdb/mmdb_coormngr.cpp mmdb/mmdb_model.cpp \ mmdb/mmdb_uddata.cpp mmdb/math_.cpp mmdb/mmdb_cryst.cpp \ mmdb/mmdb_rwbrook.cpp mmdb/mmdb_utils.cpp mmdb/mattype_.cpp \ mmdb/mmdb_ficif.cpp mmdb/mmdb_sbase0.cpp mmdb/mmdb_xml.cpp \ mmdb/mmdb_align.cpp mmdb/mmdb_file.cpp mmdb/mmdb_sbase.cpp \ mmdb/random_n.cpp mmdb/mmdb_atom.cpp mmdb/mmdb_graph.cpp \ mmdb/mmdb_selmngr.cpp mmdb/stream_.cpp mmdb/hybrid_36.cpp mmdb_libmmdb_la_LDFLAGS = -no-undefined pkgconfigdir = $(libdir)/pkgconfig pkgconfig_DATA = mmdb.pc mmdb-1.25.5/aclocal.m40000664000175000017500000011735412210624040011310 00000000000000# generated automatically by aclocal 1.12.2 -*- Autoconf -*- # Copyright (C) 1996-2012 Free Software Foundation, Inc. # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY, to the extent permitted by law; without # even the implied warranty of MERCHANTABILITY or FITNESS FOR A # PARTICULAR PURPOSE. m4_ifndef([AC_AUTOCONF_VERSION], [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.69],, [m4_warning([this file was generated for autoconf 2.69. You have another version of autoconf. It may work, but is not guaranteed to. If you have problems, you may need to regenerate the build system entirely. To do so, use the procedure documented by the package, typically 'autoreconf'.])]) # Copyright (C) 2002-2012 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # serial 8 # AM_AUTOMAKE_VERSION(VERSION) # ---------------------------- # Automake X.Y traces this macro to ensure aclocal.m4 has been # generated from the m4 files accompanying Automake X.Y. # (This private macro should not be called outside this file.) AC_DEFUN([AM_AUTOMAKE_VERSION], [am__api_version='1.12' dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to dnl require some minimum version. Point them to the right macro. m4_if([$1], [1.12.2], [], [AC_FATAL([Do not call $0, use AM_INIT_AUTOMAKE([$1]).])])dnl ]) # _AM_AUTOCONF_VERSION(VERSION) # ----------------------------- # aclocal traces this macro to find the Autoconf version. # This is a private macro too. Using m4_define simplifies # the logic in aclocal, which can simply ignore this definition. m4_define([_AM_AUTOCONF_VERSION], []) # AM_SET_CURRENT_AUTOMAKE_VERSION # ------------------------------- # Call AM_AUTOMAKE_VERSION and AM_AUTOMAKE_VERSION so they can be traced. # This function is AC_REQUIREd by AM_INIT_AUTOMAKE. AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION], [AM_AUTOMAKE_VERSION([1.12.2])dnl m4_ifndef([AC_AUTOCONF_VERSION], [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl _AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCONF_VERSION]))]) # Copyright (C) 2011-2012 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # serial 1 # AM_PROG_AR([ACT-IF-FAIL]) # ------------------------- # Try to determine the archiver interface, and trigger the ar-lib wrapper # if it is needed. If the detection of archiver interface fails, run # ACT-IF-FAIL (default is to abort configure with a proper error message). AC_DEFUN([AM_PROG_AR], [AC_BEFORE([$0], [LT_INIT])dnl AC_BEFORE([$0], [AC_PROG_LIBTOOL])dnl AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl AC_REQUIRE_AUX_FILE([ar-lib])dnl AC_CHECK_TOOLS([AR], [ar lib "link -lib"], [false]) : ${AR=ar} AC_CACHE_CHECK([the archiver ($AR) interface], [am_cv_ar_interface], [am_cv_ar_interface=ar AC_COMPILE_IFELSE([AC_LANG_SOURCE([[int some_variable = 0;]])], [am_ar_try='$AR cru libconftest.a conftest.$ac_objext >&AS_MESSAGE_LOG_FD' AC_TRY_EVAL([am_ar_try]) if test "$ac_status" -eq 0; then am_cv_ar_interface=ar else am_ar_try='$AR -NOLOGO -OUT:conftest.lib conftest.$ac_objext >&AS_MESSAGE_LOG_FD' AC_TRY_EVAL([am_ar_try]) if test "$ac_status" -eq 0; then am_cv_ar_interface=lib else am_cv_ar_interface=unknown fi fi rm -f conftest.lib libconftest.a ]) ]) case $am_cv_ar_interface in ar) ;; lib) # Microsoft lib, so override with the ar-lib wrapper script. # FIXME: It is wrong to rewrite AR. # But if we don't then we get into trouble of one sort or another. # A longer-term fix would be to have automake use am__AR in this case, # and then we could set am__AR="$am_aux_dir/ar-lib \$(AR)" or something # similar. AR="$am_aux_dir/ar-lib $AR" ;; unknown) m4_default([$1], [AC_MSG_ERROR([could not determine $AR interface])]) ;; esac AC_SUBST([AR])dnl ]) # AM_AUX_DIR_EXPAND -*- Autoconf -*- # Copyright (C) 2001-2012 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # serial 2 # For projects using AC_CONFIG_AUX_DIR([foo]), Autoconf sets # $ac_aux_dir to '$srcdir/foo'. In other projects, it is set to # '$srcdir', '$srcdir/..', or '$srcdir/../..'. # # Of course, Automake must honor this variable whenever it calls a # tool from the auxiliary directory. The problem is that $srcdir (and # therefore $ac_aux_dir as well) can be either absolute or relative, # depending on how configure is run. This is pretty annoying, since # it makes $ac_aux_dir quite unusable in subdirectories: in the top # source directory, any form will work fine, but in subdirectories a # relative path needs to be adjusted first. # # $ac_aux_dir/missing # fails when called from a subdirectory if $ac_aux_dir is relative # $top_srcdir/$ac_aux_dir/missing # fails if $ac_aux_dir is absolute, # fails when called from a subdirectory in a VPATH build with # a relative $ac_aux_dir # # The reason of the latter failure is that $top_srcdir and $ac_aux_dir # are both prefixed by $srcdir. In an in-source build this is usually # harmless because $srcdir is '.', but things will broke when you # start a VPATH build or use an absolute $srcdir. # # So we could use something similar to $top_srcdir/$ac_aux_dir/missing, # iff we strip the leading $srcdir from $ac_aux_dir. That would be: # am_aux_dir='\$(top_srcdir)/'`expr "$ac_aux_dir" : "$srcdir//*\(.*\)"` # and then we would define $MISSING as # MISSING="\${SHELL} $am_aux_dir/missing" # This will work as long as MISSING is not called from configure, because # unfortunately $(top_srcdir) has no meaning in configure. # However there are other variables, like CC, which are often used in # configure, and could therefore not use this "fixed" $ac_aux_dir. # # Another solution, used here, is to always expand $ac_aux_dir to an # absolute PATH. The drawback is that using absolute paths prevent a # configured tree to be moved without reconfiguration. AC_DEFUN([AM_AUX_DIR_EXPAND], [dnl Rely on autoconf to set up CDPATH properly. AC_PREREQ([2.50])dnl # expand $ac_aux_dir to an absolute path am_aux_dir=`cd $ac_aux_dir && pwd` ]) # AM_CONDITIONAL -*- Autoconf -*- # Copyright (C) 1997-2012 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # serial 10 # AM_CONDITIONAL(NAME, SHELL-CONDITION) # ------------------------------------- # Define a conditional. AC_DEFUN([AM_CONDITIONAL], [AC_PREREQ([2.52])dnl m4_if([$1], [TRUE], [AC_FATAL([$0: invalid condition: $1])], [$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl AC_SUBST([$1_TRUE])dnl AC_SUBST([$1_FALSE])dnl _AM_SUBST_NOTMAKE([$1_TRUE])dnl _AM_SUBST_NOTMAKE([$1_FALSE])dnl m4_define([_AM_COND_VALUE_$1], [$2])dnl if $2; then $1_TRUE= $1_FALSE='#' else $1_TRUE='#' $1_FALSE= fi AC_CONFIG_COMMANDS_PRE( [if test -z "${$1_TRUE}" && test -z "${$1_FALSE}"; then AC_MSG_ERROR([[conditional "$1" was never defined. Usually this means the macro was only invoked conditionally.]]) fi])]) # Copyright (C) 1999-2012 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # serial 17 # There are a few dirty hacks below to avoid letting 'AC_PROG_CC' be # written in clear, in which case automake, when reading aclocal.m4, # will think it sees a *use*, and therefore will trigger all it's # C support machinery. Also note that it means that autoscan, seeing # CC etc. in the Makefile, will ask for an AC_PROG_CC use... # _AM_DEPENDENCIES(NAME) # ---------------------- # See how the compiler implements dependency checking. # NAME is "CC", "CXX", "OBJC", "OBJCXX", "UPC", or "GJC". # We try a few techniques and use that to set a single cache variable. # # We don't AC_REQUIRE the corresponding AC_PROG_CC since the latter was # modified to invoke _AM_DEPENDENCIES(CC); we would have a circular # dependency, and given that the user is not expected to run this macro, # just rely on AC_PROG_CC. AC_DEFUN([_AM_DEPENDENCIES], [AC_REQUIRE([AM_SET_DEPDIR])dnl AC_REQUIRE([AM_OUTPUT_DEPENDENCY_COMMANDS])dnl AC_REQUIRE([AM_MAKE_INCLUDE])dnl AC_REQUIRE([AM_DEP_TRACK])dnl m4_if([$1], [CC], [depcc="$CC" am_compiler_list=], [$1], [CXX], [depcc="$CXX" am_compiler_list=], [$1], [OBJC], [depcc="$OBJC" am_compiler_list='gcc3 gcc'], [$1], [OBJCXX], [depcc="$OBJCXX" am_compiler_list='gcc3 gcc'], [$1], [UPC], [depcc="$UPC" am_compiler_list=], [$1], [GCJ], [depcc="$GCJ" am_compiler_list='gcc3 gcc'], [depcc="$$1" am_compiler_list=]) AC_CACHE_CHECK([dependency style of $depcc], [am_cv_$1_dependencies_compiler_type], [if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then # We make a subdir and do the tests there. Otherwise we can end up # making bogus files that we don't know about and never remove. For # instance it was reported that on HP-UX the gcc test will end up # making a dummy file named 'D' -- because '-MD' means "put the output # in D". rm -rf conftest.dir mkdir conftest.dir # Copy depcomp to subdir because otherwise we won't find it if we're # using a relative directory. cp "$am_depcomp" conftest.dir cd conftest.dir # We will build objects and dependencies in a subdirectory because # it helps to detect inapplicable dependency modes. For instance # both Tru64's cc and ICC support -MD to output dependencies as a # side effect of compilation, but ICC will put the dependencies in # the current directory while Tru64 will put them in the object # directory. mkdir sub am_cv_$1_dependencies_compiler_type=none if test "$am_compiler_list" = ""; then am_compiler_list=`sed -n ['s/^#*\([a-zA-Z0-9]*\))$/\1/p'] < ./depcomp` fi am__universal=false m4_case([$1], [CC], [case " $depcc " in #( *\ -arch\ *\ -arch\ *) am__universal=true ;; esac], [CXX], [case " $depcc " in #( *\ -arch\ *\ -arch\ *) am__universal=true ;; esac]) for depmode in $am_compiler_list; do # Setup a source with many dependencies, because some compilers # like to wrap large dependency lists on column 80 (with \), and # we should not choose a depcomp mode which is confused by this. # # We need to recreate these files for each test, as the compiler may # overwrite some of them when testing with obscure command lines. # This happens at least with the AIX C compiler. : > sub/conftest.c for i in 1 2 3 4 5 6; do echo '#include "conftst'$i'.h"' >> sub/conftest.c # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with # Solaris 10 /bin/sh. echo '/* dummy */' > sub/conftst$i.h done echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf # We check with '-c' and '-o' for the sake of the "dashmstdout" # mode. It turns out that the SunPro C++ compiler does not properly # handle '-M -o', and we need to detect this. Also, some Intel # versions had trouble with output in subdirs. am__obj=sub/conftest.${OBJEXT-o} am__minus_obj="-o $am__obj" case $depmode in gcc) # This depmode causes a compiler race in universal mode. test "$am__universal" = false || continue ;; nosideeffect) # After this tag, mechanisms are not by side-effect, so they'll # only be used when explicitly requested. if test "x$enable_dependency_tracking" = xyes; then continue else break fi ;; msvc7 | msvc7msys | msvisualcpp | msvcmsys) # This compiler won't grok '-c -o', but also, the minuso test has # not run yet. These depmodes are late enough in the game, and # so weak that their functioning should not be impacted. am__obj=conftest.${OBJEXT-o} am__minus_obj= ;; none) break ;; esac if depmode=$depmode \ source=sub/conftest.c object=$am__obj \ depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \ $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \ >/dev/null 2>conftest.err && grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 && grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 && grep $am__obj sub/conftest.Po > /dev/null 2>&1 && ${MAKE-make} -s -f confmf > /dev/null 2>&1; then # icc doesn't choke on unknown options, it will just issue warnings # or remarks (even with -Werror). So we grep stderr for any message # that says an option was ignored or not supported. # When given -MP, icc 7.0 and 7.1 complain thusly: # icc: Command line warning: ignoring option '-M'; no argument required # The diagnosis changed in icc 8.0: # icc: Command line remark: option '-MP' not supported if (grep 'ignoring option' conftest.err || grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else am_cv_$1_dependencies_compiler_type=$depmode break fi fi done cd .. rm -rf conftest.dir else am_cv_$1_dependencies_compiler_type=none fi ]) AC_SUBST([$1DEPMODE], [depmode=$am_cv_$1_dependencies_compiler_type]) AM_CONDITIONAL([am__fastdep$1], [ test "x$enable_dependency_tracking" != xno \ && test "$am_cv_$1_dependencies_compiler_type" = gcc3]) ]) # AM_SET_DEPDIR # ------------- # Choose a directory name for dependency files. # This macro is AC_REQUIREd in _AM_DEPENDENCIES. AC_DEFUN([AM_SET_DEPDIR], [AC_REQUIRE([AM_SET_LEADING_DOT])dnl AC_SUBST([DEPDIR], ["${am__leading_dot}deps"])dnl ]) # AM_DEP_TRACK # ------------ AC_DEFUN([AM_DEP_TRACK], [AC_ARG_ENABLE([dependency-tracking], [dnl AS_HELP_STRING( [--enable-dependency-tracking], [do not reject slow dependency extractors]) AS_HELP_STRING( [--disable-dependency-tracking], [speeds up one-time build])]) if test "x$enable_dependency_tracking" != xno; then am_depcomp="$ac_aux_dir/depcomp" AMDEPBACKSLASH='\' am__nodep='_no' fi AM_CONDITIONAL([AMDEP], [test "x$enable_dependency_tracking" != xno]) AC_SUBST([AMDEPBACKSLASH])dnl _AM_SUBST_NOTMAKE([AMDEPBACKSLASH])dnl AC_SUBST([am__nodep])dnl _AM_SUBST_NOTMAKE([am__nodep])dnl ]) # Generate code to set up dependency tracking. -*- Autoconf -*- # Copyright (C) 1999-2012 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # serial 6 # _AM_OUTPUT_DEPENDENCY_COMMANDS # ------------------------------ AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS], [{ # Autoconf 2.62 quotes --file arguments for eval, but not when files # are listed without --file. Let's play safe and only enable the eval # if we detect the quoting. case $CONFIG_FILES in *\'*) eval set x "$CONFIG_FILES" ;; *) set x $CONFIG_FILES ;; esac shift for mf do # Strip MF so we end up with the name of the file. mf=`echo "$mf" | sed -e 's/:.*$//'` # Check whether this is an Automake generated Makefile or not. # We used to match only the files named 'Makefile.in', but # some people rename them; so instead we look at the file content. # Grep'ing the first line is not enough: some people post-process # each Makefile.in and add a new line on top of each file to say so. # Grep'ing the whole file is not good either: AIX grep has a line # limit of 2048, but all sed's we know have understand at least 4000. if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then dirpart=`AS_DIRNAME("$mf")` else continue fi # Extract the definition of DEPDIR, am__include, and am__quote # from the Makefile without running 'make'. DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"` test -z "$DEPDIR" && continue am__include=`sed -n 's/^am__include = //p' < "$mf"` test -z "am__include" && continue am__quote=`sed -n 's/^am__quote = //p' < "$mf"` # Find all dependency output files, they are included files with # $(DEPDIR) in their names. We invoke sed twice because it is the # simplest approach to changing $(DEPDIR) to its actual value in the # expansion. for file in `sed -n " s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \ sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do # Make sure the directory exists. test -f "$dirpart/$file" && continue fdir=`AS_DIRNAME(["$file"])` AS_MKDIR_P([$dirpart/$fdir]) # echo "creating $dirpart/$file" echo '# dummy' > "$dirpart/$file" done done } ])# _AM_OUTPUT_DEPENDENCY_COMMANDS # AM_OUTPUT_DEPENDENCY_COMMANDS # ----------------------------- # This macro should only be invoked once -- use via AC_REQUIRE. # # This code is only required when automatic dependency tracking # is enabled. FIXME. This creates each '.P' file that we will # need in order to bootstrap the dependency handling code. AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS], [AC_CONFIG_COMMANDS([depfiles], [test x"$AMDEP_TRUE" != x"" || _AM_OUTPUT_DEPENDENCY_COMMANDS], [AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"]) ]) # Do all the work for Automake. -*- Autoconf -*- # Copyright (C) 1996-2012 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # serial 19 # This macro actually does too much. Some checks are only needed if # your package does certain things. But this isn't really a big deal. # AM_INIT_AUTOMAKE(PACKAGE, VERSION, [NO-DEFINE]) # AM_INIT_AUTOMAKE([OPTIONS]) # ----------------------------------------------- # The call with PACKAGE and VERSION arguments is the old style # call (pre autoconf-2.50), which is being phased out. PACKAGE # and VERSION should now be passed to AC_INIT and removed from # the call to AM_INIT_AUTOMAKE. # We support both call styles for the transition. After # the next Automake release, Autoconf can make the AC_INIT # arguments mandatory, and then we can depend on a new Autoconf # release and drop the old call support. AC_DEFUN([AM_INIT_AUTOMAKE], [AC_PREREQ([2.62])dnl dnl Autoconf wants to disallow AM_ names. We explicitly allow dnl the ones we care about. m4_pattern_allow([^AM_[A-Z]+FLAGS$])dnl AC_REQUIRE([AM_SET_CURRENT_AUTOMAKE_VERSION])dnl AC_REQUIRE([AC_PROG_INSTALL])dnl if test "`cd $srcdir && pwd`" != "`pwd`"; then # Use -I$(srcdir) only when $(srcdir) != ., so that make's output # is not polluted with repeated "-I." AC_SUBST([am__isrc], [' -I$(srcdir)'])_AM_SUBST_NOTMAKE([am__isrc])dnl # test to see if srcdir already configured if test -f $srcdir/config.status; then AC_MSG_ERROR([source directory already configured; run "make distclean" there first]) fi fi # test whether we have cygpath if test -z "$CYGPATH_W"; then if (cygpath --version) >/dev/null 2>/dev/null; then CYGPATH_W='cygpath -w' else CYGPATH_W=echo fi fi AC_SUBST([CYGPATH_W]) # Define the identity of the package. dnl Distinguish between old-style and new-style calls. m4_ifval([$2], [AC_DIAGNOSE([obsolete], [$0: two- and three-arguments forms are deprecated. For more info, see: http://www.gnu.org/software/automake/manual/automake.html#Modernize-AM_INIT_AUTOMAKE-invocation]) m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl AC_SUBST([PACKAGE], [$1])dnl AC_SUBST([VERSION], [$2])], [_AM_SET_OPTIONS([$1])dnl dnl Diagnose old-style AC_INIT with new-style AM_AUTOMAKE_INIT. m4_if( m4_ifdef([AC_PACKAGE_NAME], [ok]):m4_ifdef([AC_PACKAGE_VERSION], [ok]), [ok:ok],, [m4_fatal([AC_INIT should be called with package and version arguments])])dnl AC_SUBST([PACKAGE], ['AC_PACKAGE_TARNAME'])dnl AC_SUBST([VERSION], ['AC_PACKAGE_VERSION'])])dnl _AM_IF_OPTION([no-define],, [AC_DEFINE_UNQUOTED([PACKAGE], ["$PACKAGE"], [Name of package]) AC_DEFINE_UNQUOTED([VERSION], ["$VERSION"], [Version number of package])])dnl # Some tools Automake needs. AC_REQUIRE([AM_SANITY_CHECK])dnl AC_REQUIRE([AC_ARG_PROGRAM])dnl AM_MISSING_PROG([ACLOCAL], [aclocal-${am__api_version}]) AM_MISSING_PROG([AUTOCONF], [autoconf]) AM_MISSING_PROG([AUTOMAKE], [automake-${am__api_version}]) AM_MISSING_PROG([AUTOHEADER], [autoheader]) AM_MISSING_PROG([MAKEINFO], [makeinfo]) AC_REQUIRE([AM_PROG_INSTALL_SH])dnl AC_REQUIRE([AM_PROG_INSTALL_STRIP])dnl AC_REQUIRE([AC_PROG_MKDIR_P])dnl # For better backward compatibility. To be removed once Automake 1.9.x # dies out for good. For more background, see: # # AC_SUBST([mkdir_p], ['$(MKDIR_P)']) # We need awk for the "check" target. The system "awk" is bad on # some platforms. AC_REQUIRE([AC_PROG_AWK])dnl AC_REQUIRE([AC_PROG_MAKE_SET])dnl AC_REQUIRE([AM_SET_LEADING_DOT])dnl _AM_IF_OPTION([tar-ustar], [_AM_PROG_TAR([ustar])], [_AM_IF_OPTION([tar-pax], [_AM_PROG_TAR([pax])], [_AM_PROG_TAR([v7])])]) _AM_IF_OPTION([no-dependencies],, [AC_PROVIDE_IFELSE([AC_PROG_CC], [_AM_DEPENDENCIES([CC])], [m4_define([AC_PROG_CC], m4_defn([AC_PROG_CC])[_AM_DEPENDENCIES([CC])])])dnl AC_PROVIDE_IFELSE([AC_PROG_CXX], [_AM_DEPENDENCIES([CXX])], [m4_define([AC_PROG_CXX], m4_defn([AC_PROG_CXX])[_AM_DEPENDENCIES([CXX])])])dnl AC_PROVIDE_IFELSE([AC_PROG_OBJC], [_AM_DEPENDENCIES([OBJC])], [m4_define([AC_PROG_OBJC], m4_defn([AC_PROG_OBJC])[_AM_DEPENDENCIES([OBJC])])])dnl dnl Support for Objective C++ was only introduced in Autoconf 2.65, dnl but we still cater to Autoconf 2.62. m4_ifdef([AC_PROG_OBJCXX], [AC_PROVIDE_IFELSE([AC_PROG_OBJCXX], [_AM_DEPENDENCIES([OBJCXX])], [m4_define([AC_PROG_OBJCXX], m4_defn([AC_PROG_OBJCXX])[_AM_DEPENDENCIES([OBJCXX])])])])dnl ]) _AM_IF_OPTION([silent-rules], [AC_REQUIRE([AM_SILENT_RULES])])dnl dnl The 'parallel-tests' driver may need to know about EXEEXT, so add the dnl 'am__EXEEXT' conditional if _AM_COMPILER_EXEEXT was seen. This macro dnl is hooked onto _AC_COMPILER_EXEEXT early, see below. AC_CONFIG_COMMANDS_PRE(dnl [m4_provide_if([_AM_COMPILER_EXEEXT], [AM_CONDITIONAL([am__EXEEXT], [test -n "$EXEEXT"])])])dnl ]) dnl Hook into '_AC_COMPILER_EXEEXT' early to learn its expansion. Do not dnl add the conditional right here, as _AC_COMPILER_EXEEXT may be further dnl mangled by Autoconf and run in a shell conditional statement. m4_define([_AC_COMPILER_EXEEXT], m4_defn([_AC_COMPILER_EXEEXT])[m4_provide([_AM_COMPILER_EXEEXT])]) # When config.status generates a header, we must update the stamp-h file. # This file resides in the same directory as the config header # that is generated. The stamp files are numbered to have different names. # Autoconf calls _AC_AM_CONFIG_HEADER_HOOK (when defined) in the # loop where config.status creates the headers, so we can generate # our stamp files there. AC_DEFUN([_AC_AM_CONFIG_HEADER_HOOK], [# Compute $1's index in $config_headers. _am_arg=$1 _am_stamp_count=1 for _am_header in $config_headers :; do case $_am_header in $_am_arg | $_am_arg:* ) break ;; * ) _am_stamp_count=`expr $_am_stamp_count + 1` ;; esac done echo "timestamp for $_am_arg" >`AS_DIRNAME(["$_am_arg"])`/stamp-h[]$_am_stamp_count]) # Copyright (C) 2001-2012 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # serial 8 # AM_PROG_INSTALL_SH # ------------------ # Define $install_sh. AC_DEFUN([AM_PROG_INSTALL_SH], [AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl if test x"${install_sh}" != xset; then case $am_aux_dir in *\ * | *\ *) install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;; *) install_sh="\${SHELL} $am_aux_dir/install-sh" esac fi AC_SUBST([install_sh])]) # Copyright (C) 2003-2012 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # serial 2 # Check whether the underlying file-system supports filenames # with a leading dot. For instance MS-DOS doesn't. AC_DEFUN([AM_SET_LEADING_DOT], [rm -rf .tst 2>/dev/null mkdir .tst 2>/dev/null if test -d .tst; then am__leading_dot=. else am__leading_dot=_ fi rmdir .tst 2>/dev/null AC_SUBST([am__leading_dot])]) # Add --enable-maintainer-mode option to configure. -*- Autoconf -*- # From Jim Meyering # Copyright (C) 1996-2012 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # serial 7 # AM_MAINTAINER_MODE([DEFAULT-MODE]) # ---------------------------------- # Control maintainer-specific portions of Makefiles. # Default is to disable them, unless 'enable' is passed literally. # For symmetry, 'disable' may be passed as well. Anyway, the user # can override the default with the --enable/--disable switch. AC_DEFUN([AM_MAINTAINER_MODE], [m4_case(m4_default([$1], [disable]), [enable], [m4_define([am_maintainer_other], [disable])], [disable], [m4_define([am_maintainer_other], [enable])], [m4_define([am_maintainer_other], [enable]) m4_warn([syntax], [unexpected argument to AM@&t@_MAINTAINER_MODE: $1])]) AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles]) dnl maintainer-mode's default is 'disable' unless 'enable' is passed AC_ARG_ENABLE([maintainer-mode], [AS_HELP_STRING([--]am_maintainer_other[-maintainer-mode], am_maintainer_other[ make rules and dependencies not useful (and sometimes confusing) to the casual installer])], [USE_MAINTAINER_MODE=$enableval], [USE_MAINTAINER_MODE=]m4_if(am_maintainer_other, [enable], [no], [yes])) AC_MSG_RESULT([$USE_MAINTAINER_MODE]) AM_CONDITIONAL([MAINTAINER_MODE], [test $USE_MAINTAINER_MODE = yes]) MAINT=$MAINTAINER_MODE_TRUE AC_SUBST([MAINT])dnl ] ) AU_DEFUN([jm_MAINTAINER_MODE], [AM_MAINTAINER_MODE]) # Check to see how 'make' treats includes. -*- Autoconf -*- # Copyright (C) 2001-2012 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # serial 5 # AM_MAKE_INCLUDE() # ----------------- # Check to see how make treats includes. AC_DEFUN([AM_MAKE_INCLUDE], [am_make=${MAKE-make} cat > confinc << 'END' am__doit: @echo this is the am__doit target .PHONY: am__doit END # If we don't find an include directive, just comment out the code. AC_MSG_CHECKING([for style of include used by $am_make]) am__include="#" am__quote= _am_result=none # First try GNU make style include. echo "include confinc" > confmf # Ignore all kinds of additional output from 'make'. case `$am_make -s -f confmf 2> /dev/null` in #( *the\ am__doit\ target*) am__include=include am__quote= _am_result=GNU ;; esac # Now try BSD make style include. if test "$am__include" = "#"; then echo '.include "confinc"' > confmf case `$am_make -s -f confmf 2> /dev/null` in #( *the\ am__doit\ target*) am__include=.include am__quote="\"" _am_result=BSD ;; esac fi AC_SUBST([am__include]) AC_SUBST([am__quote]) AC_MSG_RESULT([$_am_result]) rm -f confinc confmf ]) # Fake the existence of programs that GNU maintainers use. -*- Autoconf -*- # Copyright (C) 1997-2012 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # serial 7 # AM_MISSING_PROG(NAME, PROGRAM) # ------------------------------ AC_DEFUN([AM_MISSING_PROG], [AC_REQUIRE([AM_MISSING_HAS_RUN]) $1=${$1-"${am_missing_run}$2"} AC_SUBST($1)]) # AM_MISSING_HAS_RUN # ------------------ # Define MISSING if not defined so far and test if it supports --run. # If it does, set am_missing_run to use it, otherwise, to nothing. AC_DEFUN([AM_MISSING_HAS_RUN], [AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl AC_REQUIRE_AUX_FILE([missing])dnl if test x"${MISSING+set}" != xset; then case $am_aux_dir in *\ * | *\ *) MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;; *) MISSING="\${SHELL} $am_aux_dir/missing" ;; esac fi # Use eval to expand $SHELL if eval "$MISSING --run true"; then am_missing_run="$MISSING --run " else am_missing_run= AC_MSG_WARN(['missing' script is too old or missing]) fi ]) # Helper functions for option handling. -*- Autoconf -*- # Copyright (C) 2001-2012 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # serial 6 # _AM_MANGLE_OPTION(NAME) # ----------------------- AC_DEFUN([_AM_MANGLE_OPTION], [[_AM_OPTION_]m4_bpatsubst($1, [[^a-zA-Z0-9_]], [_])]) # _AM_SET_OPTION(NAME) # -------------------- # Set option NAME. Presently that only means defining a flag for this option. AC_DEFUN([_AM_SET_OPTION], [m4_define(_AM_MANGLE_OPTION([$1]), [1])]) # _AM_SET_OPTIONS(OPTIONS) # ------------------------ # OPTIONS is a space-separated list of Automake options. AC_DEFUN([_AM_SET_OPTIONS], [m4_foreach_w([_AM_Option], [$1], [_AM_SET_OPTION(_AM_Option)])]) # _AM_IF_OPTION(OPTION, IF-SET, [IF-NOT-SET]) # ------------------------------------------- # Execute IF-SET if OPTION is set, IF-NOT-SET otherwise. AC_DEFUN([_AM_IF_OPTION], [m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])]) # Check to make sure that the build environment is sane. -*- Autoconf -*- # Copyright (C) 1996-2012 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # serial 9 # AM_SANITY_CHECK # --------------- AC_DEFUN([AM_SANITY_CHECK], [AC_MSG_CHECKING([whether build environment is sane]) # Reject unsafe characters in $srcdir or the absolute working directory # name. Accept space and tab only in the latter. am_lf=' ' case `pwd` in *[[\\\"\#\$\&\'\`$am_lf]]*) AC_MSG_ERROR([unsafe absolute working directory name]);; esac case $srcdir in *[[\\\"\#\$\&\'\`$am_lf\ \ ]]*) AC_MSG_ERROR([unsafe srcdir value: '$srcdir']);; esac # Do 'set' in a subshell so we don't clobber the current shell's # arguments. Must try -L first in case configure is actually a # symlink; some systems play weird games with the mod time of symlinks # (eg FreeBSD returns the mod time of the symlink's containing # directory). if ( am_has_slept=no for am_try in 1 2; do echo "timestamp, slept: $am_has_slept" > conftest.file set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null` if test "$[*]" = "X"; then # -L didn't work. set X `ls -t "$srcdir/configure" conftest.file` fi if test "$[*]" != "X $srcdir/configure conftest.file" \ && test "$[*]" != "X conftest.file $srcdir/configure"; then # If neither matched, then we have a broken ls. This can happen # if, for instance, CONFIG_SHELL is bash and it inherits a # broken ls alias from the environment. This has actually # happened. Such a system could not be considered "sane". AC_MSG_ERROR([ls -t appears to fail. Make sure there is not a broken alias in your environment]) fi if test "$[2]" = conftest.file || test $am_try -eq 2; then break fi # Just in case. sleep 1 am_has_slept=yes done test "$[2]" = conftest.file ) then # Ok. : else AC_MSG_ERROR([newly created file is older than distributed files! Check your system clock]) fi AC_MSG_RESULT([yes]) # If we didn't sleep, we still need to ensure time stamps of config.status and # generated files are strictly newer. am_sleep_pid= if grep 'slept: no' conftest.file >/dev/null 2>&1; then ( sleep 1 ) & am_sleep_pid=$! fi AC_CONFIG_COMMANDS_PRE( [AC_MSG_CHECKING([that generated files are newer than configure]) if test -n "$am_sleep_pid"; then # Hide warnings about reused PIDs. wait $am_sleep_pid 2>/dev/null fi AC_MSG_RESULT([done])]) rm -f conftest.file ]) # Copyright (C) 2009-2012 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # serial 3 # AM_SILENT_RULES([DEFAULT]) # -------------------------- # Enable less verbose build rules; with the default set to DEFAULT # ("yes" being less verbose, "no" or empty being verbose). AC_DEFUN([AM_SILENT_RULES], [AC_ARG_ENABLE([silent-rules], [dnl AS_HELP_STRING( [--enable-silent-rules], [less verbose build output (undo: "make V=1")]) AS_HELP_STRING( [--disable-silent-rules], [verbose build output (undo: "make V=0")])dnl ]) case $enable_silent_rules in @%:@ ((( yes) AM_DEFAULT_VERBOSITY=0;; no) AM_DEFAULT_VERBOSITY=1;; *) AM_DEFAULT_VERBOSITY=m4_if([$1], [yes], [0], [1]);; esac dnl dnl A few 'make' implementations (e.g., NonStop OS and NextStep) dnl do not support nested variable expansions. dnl See automake bug#9928 and bug#10237. am_make=${MAKE-make} AC_CACHE_CHECK([whether $am_make supports nested variables], [am_cv_make_support_nested_variables], [if AS_ECHO([['TRUE=$(BAR$(V)) BAR0=false BAR1=true V=1 am__doit: @$(TRUE) .PHONY: am__doit']]) | $am_make -f - >/dev/null 2>&1; then am_cv_make_support_nested_variables=yes else am_cv_make_support_nested_variables=no fi]) if test $am_cv_make_support_nested_variables = yes; then dnl Using '$V' instead of '$(V)' breaks IRIX make. AM_V='$(V)' AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)' else AM_V=$AM_DEFAULT_VERBOSITY AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY fi AC_SUBST([AM_V])dnl AM_SUBST_NOTMAKE([AM_V])dnl AC_SUBST([AM_DEFAULT_V])dnl AM_SUBST_NOTMAKE([AM_DEFAULT_V])dnl AC_SUBST([AM_DEFAULT_VERBOSITY])dnl AM_BACKSLASH='\' AC_SUBST([AM_BACKSLASH])dnl _AM_SUBST_NOTMAKE([AM_BACKSLASH])dnl ]) # Copyright (C) 2001-2012 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # serial 2 # AM_PROG_INSTALL_STRIP # --------------------- # One issue with vendor 'install' (even GNU) is that you can't # specify the program used to strip binaries. This is especially # annoying in cross-compiling environments, where the build's strip # is unlikely to handle the host's binaries. # Fortunately install-sh will honor a STRIPPROG variable, so we # always use install-sh in "make install-strip", and initialize # STRIPPROG with the value of the STRIP variable (set by the user). AC_DEFUN([AM_PROG_INSTALL_STRIP], [AC_REQUIRE([AM_PROG_INSTALL_SH])dnl # Installed binaries are usually stripped using 'strip' when the user # run "make install-strip". However 'strip' might not be the right # tool to use in cross-compilation environments, therefore Automake # will honor the 'STRIP' environment variable to overrule this program. dnl Don't test for $cross_compiling = yes, because it might be 'maybe'. if test "$cross_compiling" != no; then AC_CHECK_TOOL([STRIP], [strip], :) fi INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s" AC_SUBST([INSTALL_STRIP_PROGRAM])]) # Copyright (C) 2006-2012 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # serial 3 # _AM_SUBST_NOTMAKE(VARIABLE) # --------------------------- # Prevent Automake from outputting VARIABLE = @VARIABLE@ in Makefile.in. # This macro is traced by Automake. AC_DEFUN([_AM_SUBST_NOTMAKE]) # AM_SUBST_NOTMAKE(VARIABLE) # -------------------------- # Public sister of _AM_SUBST_NOTMAKE. AC_DEFUN([AM_SUBST_NOTMAKE], [_AM_SUBST_NOTMAKE($@)]) # Check how to create a tarball. -*- Autoconf -*- # Copyright (C) 2004-2012 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # serial 3 # _AM_PROG_TAR(FORMAT) # -------------------- # Check how to create a tarball in format FORMAT. # FORMAT should be one of 'v7', 'ustar', or 'pax'. # # Substitute a variable $(am__tar) that is a command # writing to stdout a FORMAT-tarball containing the directory # $tardir. # tardir=directory && $(am__tar) > result.tar # # Substitute a variable $(am__untar) that extract such # a tarball read from stdin. # $(am__untar) < result.tar AC_DEFUN([_AM_PROG_TAR], [# Always define AMTAR for backward compatibility. Yes, it's still used # in the wild :-( We should find a proper way to deprecate it ... AC_SUBST([AMTAR], ['$${TAR-tar}']) m4_if([$1], [v7], [am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'], [m4_case([$1], [ustar],, [pax],, [m4_fatal([Unknown tar format])]) AC_MSG_CHECKING([how to create a $1 tar archive]) # Loop over all known methods to create a tar archive until one works. _am_tools='gnutar m4_if([$1], [ustar], [plaintar]) pax cpio none' _am_tools=${am_cv_prog_tar_$1-$_am_tools} # Do not fold the above two line into one, because Tru64 sh and # Solaris sh will not grok spaces in the rhs of '-'. for _am_tool in $_am_tools do case $_am_tool in gnutar) for _am_tar in tar gnutar gtar; do AM_RUN_LOG([$_am_tar --version]) && break done am__tar="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$$tardir"' am__tar_="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$tardir"' am__untar="$_am_tar -xf -" ;; plaintar) # Must skip GNU tar: if it does not support --format= it doesn't create # ustar tarball either. (tar --version) >/dev/null 2>&1 && continue am__tar='tar chf - "$$tardir"' am__tar_='tar chf - "$tardir"' am__untar='tar xf -' ;; pax) am__tar='pax -L -x $1 -w "$$tardir"' am__tar_='pax -L -x $1 -w "$tardir"' am__untar='pax -r' ;; cpio) am__tar='find "$$tardir" -print | cpio -o -H $1 -L' am__tar_='find "$tardir" -print | cpio -o -H $1 -L' am__untar='cpio -i -H $1 -d' ;; none) am__tar=false am__tar_=false am__untar=false ;; esac # If the value was cached, stop now. We just wanted to have am__tar # and am__untar set. test -n "${am_cv_prog_tar_$1}" && break # tar/untar a dummy directory, and stop if the command works rm -rf conftest.dir mkdir conftest.dir echo GrepMe > conftest.dir/file AM_RUN_LOG([tardir=conftest.dir && eval $am__tar_ >conftest.tar]) rm -rf conftest.dir if test -s conftest.tar; then AM_RUN_LOG([$am__untar /dev/null 2>&1 && break fi done rm -rf conftest.dir AC_CACHE_VAL([am_cv_prog_tar_$1], [am_cv_prog_tar_$1=$_am_tool]) AC_MSG_RESULT([$am_cv_prog_tar_$1])]) AC_SUBST([am__tar]) AC_SUBST([am__untar]) ]) # _AM_PROG_TAR m4_include([m4/libtool.m4]) m4_include([m4/ltoptions.m4]) m4_include([m4/ltsugar.m4]) m4_include([m4/ltversion.m4]) m4_include([m4/lt~obsolete.m4]) mmdb-1.25.5/configure.ac0000664000175000017500000000124412162051331011727 00000000000000 AC_INIT(mmdb, 1.25.5) # keep in sync with mmdb/mmdb_defs.h AC_CONFIG_AUX_DIR(build-aux) AC_CONFIG_MACRO_DIR(m4) AC_CONFIG_SRCDIR(mmdb/mmdb_align.cpp) AC_CONFIG_HEADERS(config.h) AM_INIT_AUTOMAKE([1.11 foreign subdir-objects silent-rules -Wall]) AM_PROG_AR LT_INIT([disable-shared win32-dll]) AC_PROG_CXX # AC_PROG_CXX doesn't fail if compiler is not found, test it explicitely AC_LANG_PUSH(C++) AC_LINK_IFELSE([AC_LANG_PROGRAM([], [])], [], [AC_MSG_ERROR([C++ compiler not found.])]) AC_LANG_POP(C++) AM_MAINTAINER_MODE dnl disable (by default) maintainer mode AC_SEARCH_LIBS([cos], [m], [], [AC_MSG_ERROR([need math library])]) AC_OUTPUT(Makefile mmdb.pc) mmdb-1.25.5/README0000775000175000017500000000246211736610510010335 00000000000000==================================================== KNOWN INCOMPATIBILITIES WITH PREVIOUS VERSIONS ==================================================== -------------------------- Version 1.05 (26.03.2004) -------------------------- 1. CAtom::GetBonds ( RPSAtomBond AtomBond, int & nAtomBonds ); now returns a pointer to internal list of bonded atoms. Therefore application MUST NEITHER attempt to deallocate AtomBond obtained from this function NOR modify it (doing so will cause crash). This is in difference of previous versions where deallocation of AtomBond was explicitely required. 2. CAtom::GetBonds ( RPSAtomBondI AtomBondI, int & nAtomBonds ); on contrary, now returns an allocated instance of the atom's bond list. If AtomBondI is not NULL on input, the function attempts to deallocate it (which will cause crash if you feed uninitialized non-NULL AtomBondI into the function). Application is responsible for deallocation of AtomBondI when appropriate. 3. CAtom::GetBonds ( PSAtomBondI AtomBondI, int & nAtomBonds, int maxlength ); is a new function for pre-allocated AtomBondI[0..maxlength]. Application is responsible for allocation and deallocation of AtomBondI. 4. CAtom::GetBonds ( RPSAtomBond AtomBond, int & nAtomBonds, int maxlength ); removed as there is no need in it in view of change #1 above. mmdb-1.25.5/mmdb/0000775000175000017500000000000012210630167010443 500000000000000mmdb-1.25.5/mmdb/hybrid_36.cpp0000775000175000017500000002005711736610510012671 00000000000000 // // This is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // /*! C port of the hy36encode() and hy36decode() functions in the hybrid_36.py Python prototype/reference implementation. See the Python script for more information. This file has no external dependencies, NOT even standard C headers. Optionally, use hybrid_36_c.h, or simply copy the declarations into your code. This file is unrestricted Open Source (cctbx.sf.net). Please send corrections and enhancements to cctbx@cci.lbl.gov . See also: http://cci.lbl.gov/hybrid_36/ Ralf W. Grosse-Kunstleve, Feb 2007. */ /* The following #include may be commented out. It is here only to enforce consistency of the declarations and the definitions. */ #ifndef IOTBX_PDB_HYBRID_36_C_H #include "hybrid_36.h" #endif /* All static functions below are implementation details (and not accessible from other translation units). */ static const char* digits_upper() { return "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; } static const char* digits_lower() { return "0123456789abcdefghijklmnopqrstuvwxyz"; } static const char* value_out_of_range() { return "value out of range."; } static const char* invalid_number_literal() { return "invalid number literal."; } static const char* unsupported_width() { return "unsupported width."; } static void fill_with_stars(unsigned width, char* result) { while (width) { *result++ = '*'; width--; } *result = '\0'; } static void encode_pure( const char* digits, unsigned digits_size, unsigned width, int value, char* result) { char buf[16]; int rest; unsigned i, j; i = 0; j = 0; if (value < 0) { j = 1; value = -value; } while (1) { rest = value / digits_size; buf[i++] = digits[value - rest * digits_size]; if (rest == 0) break; value = rest; } if (j) buf[i++] = '-'; for(j=i;j 127) { *result = 0; return invalid_number_literal(); } if (si == ' ') { if (!have_non_blank) continue; value *= digits_size; } else if (si == '-') { if (have_non_blank) { *result = 0; return invalid_number_literal(); } have_non_blank = 1; have_minus = 1; continue; } else { have_non_blank = 1; dv = digits_values[si]; if (dv < 0 || dv >= (int)digits_size) { *result = 0; return invalid_number_literal(); } value *= digits_size; value += dv; } } if (have_minus) value = -value; *result = value; return 0; } /*! hybrid-36 encoder: converts integer value to string result width: must be 4 (e.g. for residue sequence numbers) or 5 (e.g. for atom serial numbers) value: integer value to be converted result: pointer to char array of size width+1 or greater on return result is null-terminated return value: pointer to error message, if any, or 0 on success Example usage (from C++): char result[4+1]; const char* errmsg = hy36encode(4, 12345, result); if (errmsg) throw std::runtime_error(errmsg); */ const char* hy36encode(unsigned width, int value, char* result) { int i = value; if (width == 4U) { if (i >= -999) { if (i < 10000) { encode_pure(digits_upper(), 10U, 4U, i, result); return 0; } i -= 10000; if (i < 1213056 /* 26*36**3 */) { i += 466560 /* 10*36**3 */; encode_pure(digits_upper(), 36U, 0U, i, result); return 0; } i -= 1213056; if (i < 1213056) { i += 466560; encode_pure(digits_lower(), 36U, 0U, i, result); return 0; } } } else if (width == 5U) { if (i >= -9999) { if (i < 100000) { encode_pure(digits_upper(), 10U, 5U, i, result); return 0; } i -= 100000; if (i < 43670016 /* 26*36**4 */) { i += 16796160 /* 10*36**4 */; encode_pure(digits_upper(), 36U, 0U, i, result); return 0; } i -= 43670016; if (i < 43670016) { i += 16796160; encode_pure(digits_lower(), 36U, 0U, i, result); return 0; } } } else { fill_with_stars(width, result); return unsupported_width(); } fill_with_stars(width, result); return value_out_of_range(); } /*! hybrid-36 decoder: converts string s to integer result width: must be 4 (e.g. for residue sequence numbers) or 5 (e.g. for atom serial numbers) s: string to be converted does not have to be null-terminated s_size: size of s must be equal to width, or an error message is returned otherwise result: integer holding the conversion result return value: pointer to error message, if any, or 0 on success Example usage (from C++): int result; const char* errmsg = hy36decode(width, "A1T5", 4, &result); if (errmsg) throw std::runtime_error(errmsg); */ const char* hy36decode(unsigned width, const char* s, unsigned s_size, int* result) { static int first_call = 1; static int digits_values_upper[128U]; static int digits_values_lower[128U]; static const char* ie_range = "internal error hy36decode: integer value out of range."; unsigned i; int di; const char* errmsg; if (first_call) { first_call = 0; for(i=0;i<128U;i++) digits_values_upper[i] = -1; for(i=0;i<128U;i++) digits_values_lower[i] = -1; for(i=0;i<36U;i++) { di = digits_upper()[i]; if (di < 0 || di > 127) { *result = 0; return ie_range; } digits_values_upper[di] = i; } for(i=0;i<36U;i++) { di = digits_lower()[i]; if (di < 0 || di > 127) { *result = 0; return ie_range; } digits_values_lower[di] = i; } } if (s_size == width) { di = s[0]; if (di >= 0 && di <= 127) { if (digits_values_upper[di] >= 10) { errmsg = decode_pure(digits_values_upper, 36U, s, s_size, result); if (errmsg == 0) { /* result - 10*36**(width-1) + 10**width */ if (width == 4U) (*result) -= 456560; else if (width == 5U) (*result) -= 16696160; else { *result = 0; return unsupported_width(); } return 0; } } else if (digits_values_lower[di] >= 10) { errmsg = decode_pure(digits_values_lower, 36U, s, s_size, result); if (errmsg == 0) { /* result + 16*36**(width-1) + 10**width */ if (width == 4U) (*result) += 756496; else if (width == 5U) (*result) += 26973856; else { *result = 0; return unsupported_width(); } return 0; } } else { errmsg = decode_pure(digits_values_upper, 10U, s, s_size, result); if (errmsg) return errmsg; if (!(width == 4U || width == 5U)) { *result = 0; return unsupported_width(); } return 0; } } } *result = 0; return invalid_number_literal(); } mmdb-1.25.5/mmdb/stream_.cpp0000775000175000017500000000706311736610510012534 00000000000000// $Id: stream_.cpp,v 1.20 2012/01/26 17:52:21 ekr Exp $ // ================================================================= // // CCP4 Coordinate Library: support of coordinate-related // functionality in protein crystallography applications. // // Copyright (C) Eugene Krissinel 2000-2008. // // This library is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // // ================================================================= // // 29.01.10 <-- Date of Last Modification. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ----------------------------------------------------------------- // // **** Module : CStream_ // ~~~~~~~~~ // **** Classes : CStream ( Basic Stream Class ) // ~~~~~~~~~ // // (C) E. Krissinel 1995-2010 // // ================================================================= // #ifndef __Stream__ #include "stream_.h" #endif // ========================== CStream =========================== // Each streamable class should be derived from CStream // and have constructor CClass(PCStream & Object), which should // initialize all memory of the class, and virtual functions // read(..) and write(..) (see below). Constructor CClass(PCStream&) // must not touch the Object variable. This constructor is used // only once just before read(..) function. It is assumed that // read/write functions of CClass provide storage/reading of // all vital data. Function read(..) must read data in exactly // the same way as function write(..) stores it. // For using CClass in streams, three following functions should // be supplied: // // 1. // void StreamWrite ( RCFile f, RPCClass Object ) { // StreamWrite ( f,(PCStream)PCClass ); // } // // 2. // PCStream CClassInit ( RPCStream Object ) { // return (PCStream)(new CClass(Object)); // } // // 3. // void StreamRead ( RCFile f, RPCClass Object ) { // StreamRead_ ( f,(PCStream)Object,CClassInit ); // } // // All these functions are automatically generated by macros // DefineStreamFunctions(CClass) -- in the header -- and // MakeStreamFunctions(CClass) -- in the implementation body. // Then CClass may be streamed in/out using functions #1 and #3. // StreamRead will return NULL for Object if it was not // in the stream. If Object existed before StreamRead(..) but // was not found in the stream, it will be disposed. void StreamRead_ ( RCFile f, RPCStream Object, InitStreamObject Init ) { int i; f.ReadInt ( &i ); if (i) { if (!Object) Object = Init(Object); //Object = new CStream ( Object ); Object->read ( f ); } else { if (Object) delete Object; Object = NULL; } } void StreamWrite_ ( RCFile f, RPCStream Object ) { int i; if (Object) { i = 1; f.WriteInt ( &i ); Object->write ( f ); } else { i = 0; f.WriteInt ( &i ); } } MakeStreamFunctions(CStream) mmdb-1.25.5/mmdb/mmdb_selmngr.cpp0000775000175000017500000033057512027050103013545 00000000000000// $Id: mmdb_selmngr.cpp,v 1.28 2012/01/26 17:52:21 ekr Exp $ // ================================================================= // // CCP4 Coordinate Library: support of coordinate-related // functionality in protein crystallography applications. // // Copyright (C) Eugene Krissinel 2000-2008. // // This library is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // // ================================================================= // // 29.01.10 <-- Date of Last Modification. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ----------------------------------------------------------------- // // **** Module : mmdb_selmngr // ~~~~~~~~~ // **** Project : MacroMolecular Data Base (MMDB) // ~~~~~~~~~ // **** Classes : CMMDBSelManager ( MMDB atom selection manager ) // ~~~~~~~~~ // // (C) E. Krissinel 2000-2010 // // ================================================================= // #ifndef __STRING_H #include #endif #ifndef __STDLIB_H #include #endif #ifndef __MATH_H #include #endif #ifndef __MMDB_SelMngr__ #include "mmdb_selmngr.h" #endif // ==================== CMMDBSelManager ===================== CMMDBSelManager::CMMDBSelManager() : CMMDBCoorManager() { InitMMDBSelManager(); } CMMDBSelManager::CMMDBSelManager ( RPCStream Object ) : CMMDBCoorManager(Object) { InitMMDBSelManager(); } CMMDBSelManager::~CMMDBSelManager() { DeleteAllSelections(); } void CMMDBSelManager::ResetManager() { CMMDBCoorManager::ResetManager(); DeleteAllSelections(); InitMMDBSelManager (); } void CMMDBSelManager::InitMMDBSelManager() { nSelections = 0; // number of selections Mask = NULL; // vector of selections SelType = NULL; // vector of selection types nSelItems = NULL; // numbers of selected items Selection = NULL; // vector of selected items } // ------------------------ Selection ----------------------------- int CMMDBSelManager::NewSelection() { int i,l; PCMask M; PPCMask Mask1; PPCMask * Selection1; ivector nSelItems1; ivector SelType1; M = new CMask(); M->NewMask ( Mask,nSelections ); i = 0; while (i=nSelections) { l = nSelections+10; Mask1 = new PCMask [l]; Selection1 = new PPCMask[l]; nSelItems1 = new int[l]; SelType1 = new int[l]; for (i=0;i0) && (selHnd<=nSelections)) { k = selHnd-1; if (Mask[k]) return SelType[k]; } return STYPE_INVALID; } void CMMDBSelManager::DeleteSelection ( int selHnd ) { int i,k; if ((selHnd>0) && (selHnd<=nSelections)) { k = selHnd-1; if (Mask[k]) { for (i=0;iRemoveMask ( Mask[k] ); // for (i=0;iRemoveMask ( Mask[k] ); delete Mask[k]; } Mask[k] = NULL; if (Selection[k]) delete[] Selection[k]; Selection[k] = NULL; nSelItems[k] = 0; SelType [k] = STYPE_UNDEFINED; } } PCMask CMMDBSelManager::GetSelMask ( int selHnd ) { if ((selHnd>0) && (selHnd<=nSelections)) return Mask[selHnd-1]; else return NULL; } void CMMDBSelManager::DeleteAllSelections() { PCResidue res ,res1; PCChain chain,chain1; PCModel model,model1; int i; if (Mask) { res = NULL; chain = NULL; model = NULL; if (Atom) for (i=0;iClearMask(); res1 = Atom[i]->GetResidue(); if (res1!=res) { res = res1; res->ClearMask(); chain1 = res->GetChain(); if (chain1!=chain) { chain = chain1; chain->ClearMask(); model1 = chain->GetModel(); if (model1!=model) { model = model1; model->ClearMask(); } } } } for (i=0;inSelections) || (nAtoms<=0)) return; k = selHnd-1; sk = selKey; if ((SelType[k]==STYPE_UNDEFINED) || (selKey==SKEY_NEW)) SelType[k] = STYPE_ATOM; else if (SelType[k]!=STYPE_ATOM) return; switch (selKey) { case SKEY_NEW : for (i=0;iRemoveMask ( Mask[k] ); nSelItems[k] = 0; nsel = 0; break; case SKEY_OR : if (nSelItems[k]==0) sk = SKEY_NEW; nsel = nSelItems[k]; break; case SKEY_AND : nsel = 0; break; case SKEY_XOR : nsel = nSelItems[k]; break; case SKEY_CLR : nsel = nSelItems[k]; if (nsel<=0) return; break; } if ((iSer1==0) && (iSer2==0)) { for (i=0;iTer) SelectAtom ( Atom[i],k,sk,nsel ); } } else { if (iSer1<=iSer2) { s1 = iSer1; s2 = iSer2; } else { s1 = iSer2; s2 = iSer1; } // for a very general use, we allow the serial number // to differ from the atom's index, although this is // against PDB format. Therefore we apply here the most // primitive and less efficient way of selection for (i=0;iTer) { if ((s1<=Atom[i]->serNum) && (Atom[i]->serNum<=s2)) SelectAtom ( Atom[i],k,sk,nsel ); else if (sk==SKEY_AND) Atom[i]->RemoveMask ( Mask[k] ); } } } MakeSelIndex ( selHnd,STYPE_ATOM,nsel ); } void CMMDBSelManager::SelectAtoms ( int selHnd, ivector asn, int nsn, int selKey ) { // SelectAtoms(..) selects atoms with serial numbers given in // vector asn[0..nsn-1]. CQuickSort QS; ivector asn1; int i,k,nsn1,j,j1,j2, sk,sn,nsel; if ((selHnd<=0) || (selHnd>nSelections) || (nAtoms<=0)) return; k = selHnd-1; sk = selKey; if ((SelType[k]==STYPE_UNDEFINED) || (selKey==SKEY_NEW)) SelType[k] = STYPE_ATOM; else if (SelType[k]!=STYPE_ATOM) return; switch (selKey) { case SKEY_NEW : for (i=0;iRemoveMask ( Mask[k] ); nSelItems[k] = 0; nsel = 0; break; case SKEY_OR : if (nSelItems[k]==0) sk = SKEY_NEW; nsel = nSelItems[k]; break; case SKEY_AND : nsel = 0; break; case SKEY_XOR : nsel = nSelItems[k]; break; case SKEY_CLR : nsel = nSelItems[k]; if (nsel<=0) return; break; } GetVectorMemory ( asn1,nsn,0 ); for (i=0;iTer) { sn = Atom[i]->serNum; if ((asn1[0]<=sn) && (sn<=asn1[nsn1])) { // binary search j1 = 0; j2 = nsn1; do { j = (j1+j2)/2; if (snasn1[j]) j1 = j; else j1 = j2; } while (j1RemoveMask ( Mask[k] ); } else if (sk==SKEY_AND) Atom[i]->RemoveMask ( Mask[k] ); } } FreeVectorMemory ( asn1,0 ); MakeSelIndex ( selHnd,STYPE_ATOM,nsel ); } void CMMDBSelManager::UnselectAtoms ( int selHnd, int iSer1, int iSer2 ) { // UnselectAtoms(..) clears the specified mask for atoms in // the serial number range of iSer1 to iSer2. If iSer1=iSer2=0 // then all atoms are cleared of the specified mask. If selHnd // is set to 0, then the atoms are cleared of any mask. int i,s1,s2,k; if ((selHnd<=nSelections) && (nAtoms>0)) { k = selHnd-1; if (SelType[k]==STYPE_UNDEFINED) SelType[k] = STYPE_ATOM; else if (SelType[k]!=STYPE_ATOM) return; if ((iSer1==0) && (iSer2==0)) { if (k<0) { for (i=0;iClearMask(); } else { for (i=0;iRemoveMask ( Mask[k] ); } } else { if (iSer1<=iSer2) { s1 = iSer1; s2 = iSer2; } else { s1 = iSer2; s2 = iSer1; } // for a very general use, we allow the serial number // to differ from the atom's index, although this is // against PDB format. Therefore we apply here the most // primitive and less efficient way of selection if (k<0) { for (i=0;iserNum) && (Atom[i]->serNum<=s2)) Atom[i]->ClearMask(); } } else { for (i=0;iserNum) && (Atom[i]->serNum<=s2)) Atom[i]->RemoveMask ( Mask[k] ); } } } MakeSelIndex ( selHnd,STYPE_ATOM,-1 ); } } pstr MakeList ( cpstr S ) { // makes the list of selecting items: // 1st character - special use, // then each item from S embraced by commas pstr L; int i,j; i = 0; while (S[i]==' ') i++; if (S[i]!='*') { // compile a searchable list L = new char[strlen(S)+5]; if (S[i]=='!') { L[0] = '!'; i++; } else L[0] = ' '; if (strchr(S,'[')) L[1] = '"'; else L[1] = ' '; L[2] = ','; j = 3; while (S[i]) { while (S[i]==' ') i++; if (S[i]=='[') { while (S[i] && (S[i]!=']')) L[j++] = S[i++]; L[j++] = ']'; if (S[i]==']') i++; } else while (S[i] && (S[i]!=' ') && (S[i]!=',')) L[j++] = S[i++]; while (S[i]==' ') i++; L[j++] = ','; if (S[i]==',') { i++; if (!S[i]) L[j++] = ','; // blank chain ID at the end assumed } } if (j==3) L[j++] = ','; L[j] = char(0); } else L = NULL; return L; } Boolean MatchName ( pstr L, pstr N ) { char M[MaxMMDBNameLength+5]; int i,j; if (L) { i = 0; M[0] = ','; j = 1; while (N[i]) if (N[i]==' ') i++; else M[j++] = N[i++]; M[j++] = ','; M[j] = char(0); if (strstr(&(L[2]),M)) return (L[0]!='!'); else if (L[1]!='"') return (L[0]=='!'); else { strcpy ( M,",[" ); strcat ( M,N ); strcat ( M,"]," ); if (strstr(&(L[2]),M)) return (L[0]!='!'); else return (L[0]=='!'); } } else return True; } Boolean MatchCharge ( pstr L, PCAtom atom ) { char N[100]; if (L) { if (atom->WhatIsSet & ASET_Charge) { sprintf ( N,"%+2i",mround(atom->charge) ); return MatchName ( L,N ); } else return False; } else return True; } void CMMDBSelManager::SelectAtom ( int selHnd, PCAtom A, int selKey, Boolean makeIndex ) { int i, k, sk, nsel; if ((selHnd<=0) || (selHnd>nSelections)) return; k = selHnd-1; sk = selKey; if ((SelType[k]==STYPE_UNDEFINED) || (selKey==SKEY_NEW)) SelType[k] = STYPE_ATOM; else if (SelType[k]!=STYPE_ATOM) return; switch (selKey) { case SKEY_NEW : for (i=0;iRemoveMask ( Mask[k] ); nSelItems[k] = 0; nsel = 0; break; case SKEY_OR : if (nSelItems[k]==0) sk = SKEY_NEW; nsel = nSelItems[k]; break; case SKEY_AND : if (nSelItems[k]==0) return; nsel = 0; break; case SKEY_XOR : nsel = nSelItems[k]; break; case SKEY_CLR : nsel = nSelItems[k]; if (nsel<=0) return; break; } SelectAtom ( A,k,sk,nsel); if (makeIndex) MakeSelIndex ( selHnd,STYPE_ATOM,nsel ); } void CMMDBSelManager::SelectResidue ( int selHnd, PCResidue Res, int selType, int selKey, Boolean makeIndex ) { // Selects residue Res or all its atoms depending on selType PPCAtom A; int i, k, sk, nsel, nat; if ((selHnd<=0) || (selHnd>nSelections)) return; k = selHnd-1; sk = selKey; if ((SelType[k]==STYPE_UNDEFINED) || (selKey==SKEY_NEW)) SelType[k] = selType; else if (SelType[k]!=selType) return; switch (selKey) { case SKEY_NEW : for (i=0;iRemoveMask ( Mask[k] ); nSelItems[k] = 0; nsel = 0; break; case SKEY_OR : if (nSelItems[k]==0) sk = SKEY_NEW; nsel = nSelItems[k]; break; case SKEY_AND : if (nSelItems[k]==0) return; nsel = 0; break; case SKEY_XOR : nsel = nSelItems[k]; break; case SKEY_CLR : nsel = nSelItems[k]; if (nsel<=0) return; break; } switch (selType) { case STYPE_ATOM : Res->GetAtomTable ( A,nat ); for (i=0;iTer) SelectAtom ( A[i],k,sk,nsel); } break ; case STYPE_RESIDUE : SelectObject ( Res,k,sk,nsel ); break ; default : ; } if (makeIndex) MakeSelIndex ( selHnd,selType,nsel ); } void CMMDBSelManager::SelectChain ( int selHnd, PCChain Chain, int selType, int selKey, Boolean makeIndex ) { // Selects chain Chain or all its residues or atoms depending on selType PPCAtom A; PPCResidue Res; int i,j, k, sk, nsel, nat,nres; if ((selHnd<=0) || (selHnd>nSelections)) return; k = selHnd-1; sk = selKey; if ((SelType[k]==STYPE_UNDEFINED) || (selKey==SKEY_NEW)) SelType[k] = selType; else if (SelType[k]!=selType) return; switch (selKey) { case SKEY_NEW : for (i=0;iRemoveMask ( Mask[k] ); nSelItems[k] = 0; nsel = 0; break; case SKEY_OR : if (nSelItems[k]==0) sk = SKEY_NEW; nsel = nSelItems[k]; break; case SKEY_AND : if (nSelItems[k]==0) return; nsel = 0; break; case SKEY_XOR : nsel = nSelItems[k]; break; case SKEY_CLR : nsel = nSelItems[k]; if (nsel<=0) return; break; } switch (selType) { case STYPE_ATOM : Chain->GetResidueTable ( Res,nres ); for (i=0;iGetAtomTable ( A,nat ); for (j=0;jTer) SelectAtom ( A[j],k,sk,nsel); } } break ; case STYPE_RESIDUE : Chain->GetResidueTable ( Res,nres ); for (i=0;inSelections)) return; k = selHnd-1; sk = selKey; if ((SelType[k]==STYPE_UNDEFINED) || (selKey==SKEY_NEW)) SelType[k] = selType; else if (SelType[k]!=selType) return; switch (selKey) { case SKEY_NEW : for (i=0;iRemoveMask ( Mask[k] ); nSelItems[k] = 0; nsel = 0; break; case SKEY_OR : if (nSelItems[k]==0) sk = SKEY_NEW; nsel = nSelItems[k]; break; case SKEY_AND : if (nSelItems[k]==0) return; nsel = 0; break; case SKEY_XOR : nsel = nSelItems[k]; break; case SKEY_CLR : nsel = nSelItems[k]; if (nsel<=0) return; break; } switch (selType) { case STYPE_ATOM : model->GetChainTable ( Chain,nch ); for (i=0;iGetResidueTable ( Res,nres ); for (j=0;jGetAtomTable ( A,nat ); for (n=0;nTer) SelectAtom ( A[n],k,sk,nsel); } } } break ; case STYPE_RESIDUE : model->GetChainTable ( Chain,nch ); for (i=0;iGetResidueTable ( Res,nres ); for (j=0;jGetChainTable ( Chain,nch ); for (i=0;inSelections)) return 0; k = selHnd-1; if (SelType[k]==STYPE_UNDEFINED) return 0; MakeSelIndex ( selHnd,SelType[k],-1 ); return nSelItems[k]; } void CMMDBSelManager::MakeAllSelIndexes() { int k; for (k=0;knSelections) || (nAtoms<=0)) return; modelSel = False; k = selHnd-1; sk = selKey; if ((SelType[k]==STYPE_UNDEFINED) || (selKey==SKEY_NEW)) SelType[k] = selType; else if (SelType[k]!=selType) return; // if something goes wrong, sk should be assigned SKEY_OR if // selKey is set to SKEY_NEW or SKEY_OR below switch (selKey) { case SKEY_NEW : for (i=0;iRemoveMask ( Mask[k] ); nSelItems[k] = 0; nsel = 0; break; case SKEY_OR : if (nSelItems[k]==0) sk = SKEY_NEW; nsel = nSelItems[k]; break; case SKEY_AND : nsel = 0; break; case SKEY_XOR : nsel = nSelItems[k]; break; case SKEY_CLR : nsel = nSelItems[k]; if (nsel<=0) return; break; default : return; } selAND = (selKey==SKEY_AND); altLocs1 = NULL; if (altLocs) { if (strchr(altLocs,hetIndicator)) { CreateCopy ( altLocs1,altLocs ); DelSpaces ( altLocs1 ); aloc_l = strchr ( altLocs1,hetIndicator ); aloc_l[0] = ' '; if (aloc_l[1]) aloc_l[1] = ' '; // instead of comma else if (aloc_l!=altLocs1) { aloc_l--; aloc_l[0] = ' '; } DelSpaces ( altLocs1 ); aloc_l = MakeList ( altLocs1 ); } else aloc_l = MakeList ( altLocs ); } else aloc_l = MakeList ( altLocs ); chain_l = MakeList ( Chains ); res_l = MakeList ( RNames ); atom_l = MakeList ( ANames ); elem_l = MakeList ( Elements ); segm_l = MakeList ( Segments ); charge_l = MakeList ( Charges ); // noRes==True means no residue restrictions noRes = (ResNo1==ResNo2) && (ResNo1==ANY_RES) && (Ins1[0]==Ins2[0]) && (Ins1[0]=='*'); Occ = (occ1>=0.0) || (occ2>=0.0); Dist = (d0>0.0); d02 = d0*d0; m1 = iModel-1; if (m1>=0) m2 = m1+1; // will take only this model else { m1 = 0; // will take m2 = nModels; // all models } if (m1>=nModels) return; for (n=0;nnChains;c++) { chain = model->Chain[c]; if (chain) { // again check for safety if (MatchName(chain_l,chain->chainID)) { // the chain has to be taken i = 0; if (!noRes) while (inResidues) { res = chain->Residue[i]; if (res) { if ((res->seqNum==ResNo1) && MatchName(res_l,res->name) && ((Ins1[0]=='*') || (!strcmp(res->insCode,Ins1)))) break; else if (selAND) { if (selType==STYPE_ATOM) res->UnmaskAtoms ( Mask[k] ); else if (selType==STYPE_RESIDUE) res->RemoveMask ( Mask[k] ); } } i++; } while (inResidues) { res = chain->Residue[i]; if (res) { resSel = False; // will be True on 1st sel-n in the res-e if (MatchName(res_l,res->name)) { for (j=0;jnAtoms;j++) { atom = res->atom[j]; if (atom) { if ((!atom->Ter) && MatchName(atom_l ,atom->name ) && MatchName(elem_l ,atom->element) && MatchName(aloc_l ,atom->altLoc ) && MatchName(segm_l ,atom->segID ) && MatchCharge(charge_l,atom ) && ((!altLocs1) || atom->Het)) { Sel = True; if (Occ) Sel = ((occ1<=atom->occupancy) && (atom->occupancy<=occ2)); if (Dist) { dx = atom->x - x0; dy = atom->y - y0; dz = atom->z - z0; Sel = Sel && ((dx*dx+dy*dy+dz*dz)<=d02); } } else Sel = False; if (Sel) { SelectObject ( selType,atom,k,sk,nsel ); resSel = True; chainSel = True; modelSel = True; } else if (selAND && (selType==STYPE_ATOM)) atom->RemoveMask ( Mask[k] ); } if (resSel && (selType!=STYPE_ATOM)) break; } } else if (selAND && (selType==STYPE_ATOM)) res->UnmaskAtoms ( Mask[k] ); if ((!resSel) && selAND && (selType==STYPE_RESIDUE)) res->RemoveMask ( Mask[k] ); if (chainSel && (selType>STYPE_RESIDUE)) break; if (!noRes) { if ((res->seqNum==ResNo2) && ((Ins2[0]=='*') || (!strcmp(res->insCode,Ins2))) ) break; } } i++; } if (selAND) { if (selType==STYPE_ATOM) while (inResidues) { res = chain->Residue[i]; if (res) res->UnmaskAtoms ( Mask[k] ); i++; } if (selType==STYPE_RESIDUE) while (inResidues) { res = chain->Residue[i]; if (res) res->RemoveMask ( Mask[k] ); i++; } } } else if (selAND) switch (selType) { case STYPE_ATOM : chain->UnmaskAtoms ( Mask[k] ); break; case STYPE_RESIDUE : chain->UnmaskResidues ( Mask[k] ); break; case STYPE_CHAIN : chain->RemoveMask ( Mask[k] ); break; default : ; } if ((!chainSel) && selAND && (selType==STYPE_CHAIN)) chain->RemoveMask ( Mask[k] ); if (modelSel && (selType>STYPE_CHAIN)) break; } } } else if (selAND) switch (selType) { case STYPE_ATOM : model->UnmaskAtoms ( Mask[k] ); break; case STYPE_RESIDUE : model->UnmaskResidues ( Mask[k] ); break; case STYPE_CHAIN : model->UnmaskChains ( Mask[k] ); break; default : ; } if ((!modelSel) && selAND && (selType==STYPE_MODEL)) model->RemoveMask ( Mask[k] ); } } // release dynamic memory if (chain_l) delete[] chain_l; if (res_l) delete[] res_l; if (atom_l) delete[] atom_l; if (elem_l) delete[] elem_l; if (altLocs1) delete[] altLocs1; if (aloc_l) delete[] aloc_l; if (segm_l) delete[] segm_l; if (charge_l) delete[] charge_l; MakeSelIndex ( selHnd,STYPE_ATOM,nsel ); } void CMMDBSelManager::SelectAtoms ( int selHnd, // must be obtained from NewSelection() int iModel, // model number; iModel=0 means // 'any models' cpstr Chains, // may be several chains "A,B,W"; // "*" means 'any chain' (in model) int ResNo1, // starting residue number cpstr Ins1, // starting residue insertion code; // "*" means 'any code' int ResNo2, // ending residue number. // ResNo1=ResNo2=ANY_RES means 'any // residue number' (in chain) cpstr Ins2, // ending residue insertion code // "*" means 'any code' cpstr RNames, // may be several residue names // "ALA,GLU,CIS"; "*" means 'any // residue name' cpstr ANames, // may be several names "CA,CB"; "*" // means 'any atom' (in residue) cpstr Elements, // may be several element types like // "H,C,O,CU"; "*" means 'any // element' cpstr altLocs, // may be several alternative // locations 'A,B'; "*" means 'any // alternative location' int selKey // selection key ) { Select ( selHnd,STYPE_ATOM,iModel,Chains,ResNo1,Ins1,ResNo2,Ins2, RNames,ANames,Elements,altLocs,selKey ); } int CMMDBSelManager::Select ( int selHnd, // must be obtained from NewSelection() int selType, // selection type STYPE_XXXXX cpstr CID, // coordinate ID int selKey // selection key ) { int iModel,l,RC; pstr Chains; int seqNum1 ,seqNum2; InsCode insCode1,insCode2; pstr RNames; pstr ANames; pstr Elements; pstr altLocs; l = IMax(10,strlen(CID))+1; Chains = new char[l]; RNames = new char[l]; ANames = new char[l]; Elements = new char[l]; altLocs = new char[l]; if (strcmp(CID,"-all")) { RC = ParseSelectionPath ( CID,iModel,Chains,seqNum1,insCode1, seqNum2,insCode2,RNames,ANames, Elements,altLocs ); } else { iModel = 0; strcpy ( Chains,"*" ); seqNum1 = ANY_RES; seqNum2 = ANY_RES; strcpy ( insCode1,"*" ); strcpy ( insCode2,"*" ); strcpy ( RNames ,"*" ); strcpy ( ANames ,"*" ); strcpy ( Elements,"*" ); strcpy ( altLocs ,"" ); // only main conformation by default RC = 0; } if (!RC) { Select ( selHnd,selType,iModel,Chains,seqNum1,insCode1, seqNum2,insCode2,RNames,ANames,Elements,altLocs,selKey ); RC = 0; } delete[] Chains; delete[] RNames; delete[] ANames; delete[] Elements; delete[] altLocs; return RC; } void CMMDBSelManager::Select ( int selHnd, // must be obtained from NewSelection() int selType, // selection type STYPE_XXXXX int iModel, // model number; iModel=0 means // 'any model' cpstr Chains, // may be several chains "A,B,W"; // "*" means 'any chain' (in model) int ResNo1, // starting residue number cpstr Ins1, // starting residue insertion code; // "*" means 'any code' int ResNo2, // ending residue number. // ResNo1=ResNo2=ANY_RES means 'any // residue number' (in chain) cpstr Ins2, // ending residue insertion code // "*" means 'any code' cpstr RNames, // may be several residue names // "ALA,GLU,CIS"; "*" means 'any // residue name' cpstr ANames, // may be several names "CA,CB"; "*" // means 'any atom' (in residue) cpstr Elements, // may be several element types like // "H,C,O,CU"; "*" means 'any element' cpstr altLocs, // may be several alternative // locations 'A,B'; "*" means 'any // alternative location' int selKey // selection key ) { int i,j,k,n,m1,m2,c, sk,nsel; Boolean noRes,modelSel,chainSel,resSel,selAND; PCModel model; PCChain chain; PCResidue res; PCAtom atom; pstr chain_l; pstr res_l; pstr atom_l; pstr elem_l; pstr altLocs1; pstr aloc_l; if ((selHnd<=0) || (selHnd>nSelections) || (nAtoms<=0)) return; modelSel = False; k = selHnd-1; sk = selKey; if ((SelType[k]==STYPE_UNDEFINED) || (selKey==SKEY_NEW)) SelType[k] = selType; else if (SelType[k]!=selType) return; // if something goes wrong, sk should be assigned SKEY_OR if // selKey is set to SKEY_NEW or SKEY_OR below switch (selKey) { case SKEY_NEW : for (i=0;iRemoveMask ( Mask[k] ); nSelItems[k] = 0; nsel = 0; break; case SKEY_OR : if (nSelItems[k]==0) sk = SKEY_NEW; nsel = nSelItems[k]; break; case SKEY_AND : nsel = 0; break; case SKEY_XOR : nsel = nSelItems[k]; break; case SKEY_CLR : nsel = nSelItems[k]; if (nsel<=0) return; break; default : return; } selAND = (selKey==SKEY_AND); altLocs1 = NULL; if (altLocs) { if (strchr(altLocs,hetIndicator)) { CreateCopy ( altLocs1,altLocs ); DelSpaces ( altLocs1 ); aloc_l = strchr ( altLocs1,hetIndicator ); aloc_l[0] = ' '; if (aloc_l[1]) aloc_l[1] = ' '; // instead of comma else if (aloc_l!=altLocs1) { aloc_l--; aloc_l[0] = ' '; } DelSpaces ( altLocs1 ); aloc_l = MakeList ( altLocs1 ); } else aloc_l = MakeList ( altLocs ); } else aloc_l = MakeList ( altLocs ); chain_l = MakeList ( Chains ); res_l = MakeList ( RNames ); atom_l = MakeList ( ANames ); elem_l = MakeList ( Elements ); // noRes==True means no residue restrictions noRes = (ResNo1==ResNo2) && (ResNo1==ANY_RES) && (Ins1[0]=='*') && (Ins2[0]=='*'); m1 = iModel-1; if (m1>=0) m2 = m1+1; // will take only this model else { m1 = 0; // will take m2 = nModels; // all models } if (m1>=nModels) return; for (n=0;nnChains;c++) { chain = model->Chain[c]; if (chain) { // again check for safety chainSel = False; // will be True on 1st sel-n in the chain if (MatchName(chain_l,chain->chainID)) { // the chain is to be taken i = 0; if (!noRes) // skip "leading" residues while (inResidues) { res = chain->Residue[i]; if (res) { if ((res->seqNum==ResNo1) && MatchName(res_l,res->name) && ((Ins1[0]=='*') || (!strcmp(res->insCode,Ins1)))) break; else if (selAND) { if (selType==STYPE_ATOM) res->UnmaskAtoms ( Mask[k] ); else if (selType==STYPE_RESIDUE) res->RemoveMask ( Mask[k] ); } } i++; } while (inResidues) { res = chain->Residue[i]; i++; if (res) { resSel = False; // will be True on 1st selection // in the residue if (MatchName(res_l,res->name)) { for (j=0;jnAtoms;j++) { atom = res->atom[j]; if (atom) { if ((!atom->Ter) && MatchName(atom_l,atom->name ) && MatchName(elem_l,atom->element) && MatchName(aloc_l,atom->altLoc ) && ((!altLocs1) || atom->Het)) { SelectObject ( selType,atom,k,sk,nsel ); resSel = True; chainSel = True; modelSel = True; } else if (selAND && (selType==STYPE_ATOM)) atom->RemoveMask ( Mask[k] ); } if (resSel && (selType!=STYPE_ATOM)) break; } } else if (selAND && (selType==STYPE_ATOM)) res->UnmaskAtoms ( Mask[k] ); if ((!resSel) && selAND && (selType==STYPE_RESIDUE)) res->RemoveMask ( Mask[k] ); if (chainSel && (selType>STYPE_RESIDUE)) break; if (!noRes) { if ((res->seqNum==ResNo2) && ((Ins2[0]=='*') || (!strcmp(res->insCode,Ins2))) ) break; } } } if (selAND) { if (selType==STYPE_ATOM) while (inResidues) { res = chain->Residue[i]; if (res) res->UnmaskAtoms ( Mask[k] ); i++; } if (selType==STYPE_RESIDUE) while (inResidues) { res = chain->Residue[i]; if (res) res->RemoveMask ( Mask[k] ); i++; } } } else if (selAND) switch (selType) { case STYPE_ATOM : chain->UnmaskAtoms ( Mask[k] ); break; case STYPE_RESIDUE : chain->UnmaskResidues ( Mask[k] ); break; default : ; } if ((!chainSel) && selAND && (selType==STYPE_CHAIN)) chain->RemoveMask ( Mask[k] ); if (modelSel && (selType>STYPE_CHAIN)) break; } } } else if (selAND) switch (selType) { case STYPE_ATOM : model->UnmaskAtoms ( Mask[k] ); break; case STYPE_RESIDUE : model->UnmaskResidues ( Mask[k] ); break; case STYPE_CHAIN : model->UnmaskChains ( Mask[k] ); break; default : ; } if ((!modelSel) && selAND && (selType==STYPE_MODEL)) model->RemoveMask ( Mask[k] ); } } // release dynamic memory if (chain_l) delete[] chain_l; if (res_l) delete[] res_l; if (atom_l) delete[] atom_l; if (elem_l) delete[] elem_l; if (altLocs1) delete[] altLocs1; if (aloc_l) delete[] aloc_l; MakeSelIndex ( selHnd,selType,nsel ); } #define SKEY_XAND 100 void CMMDBSelManager::Select ( int selHnd1, // destination, must be obtained from // NewSelection() int selType, // selection type STYPE_XXXXX int selHnd2, // source, must be obtained from // NewSelection() and have been used // for selection int selKey // selection key ) { // SKEY_XOR works only downward the hierarchy! int k1,k2,sk,i,j,l,n,nsel; PCAtom atom; PCResidue res; PCChain chain; PCModel model; if ((selHnd1<=0) || (selHnd1>nSelections) || (selHnd2<=0) || (selHnd2>nSelections) || (nAtoms<=0)) return; k1 = selHnd1-1; k2 = selHnd2-1; sk = selKey; if ((SelType[k1]==STYPE_UNDEFINED) || (selKey==SKEY_NEW)) SelType[k1] = selType; else if (SelType[k1]!=selType) return; if (SelType[k2]==STYPE_UNDEFINED) return; switch (selKey) { case SKEY_NEW : for (i=0;iRemoveMask ( Mask[k1] ); nSelItems[k1] = 0; sk = SKEY_OR; nsel = 0; break; case SKEY_OR : if (nSelItems[k1]==0) sk = SKEY_NEW; nsel = nSelItems[k1]; break; case SKEY_AND : if (nSelItems[k1]==0) return; sk = SKEY_XAND; nsel = 0; break; case SKEY_XOR : nsel = nSelItems[k1]; break; case SKEY_CLR : nsel = nSelItems[k1]; if (nsel<=0) return; break; default : return; } switch (SelType[k2]) { case STYPE_ATOM : for (i=0;iTer) SelectObject ( selType,atom,k1,sk,nsel ); } } break; case STYPE_RESIDUE : for (i=0;inAtoms;j++) { atom = res->atom[j]; if (atom) { if (!atom->Ter) SelectObject (atom,k1,sk,nsel); } } break; case STYPE_RESIDUE : //if (res->chain) SelectObject ( res,k1,sk,nsel ); break; case STYPE_CHAIN : if (res->chain) SelectObject ( res->chain,k1, sk,nsel ); break; case STYPE_MODEL : if (res->chain) { if (res->chain->model) SelectObject ( res->chain->model, k1,sk,nsel ); } default : ; } } break; case STYPE_CHAIN : for (i=0;inResidues;j++) { res = chain->Residue[j]; if (res) for (l=0;lnAtoms;l++) { atom = res->atom[l]; if (atom) { if (!atom->Ter) SelectObject ( atom,k1, sk,nsel ); } } } break; case STYPE_RESIDUE : for (j=0;jnResidues;j++) { res = chain->Residue[j]; if (res) SelectObject ( res,k1,sk,nsel ); } break; case STYPE_CHAIN : //if (chain->model) SelectObject ( chain,k1,sk,nsel ); break; case STYPE_MODEL : if (chain->model) SelectObject ( chain->model,k1, sk,nsel ); default : ; } } break; case STYPE_MODEL : for (i=0;inChains;j++) { chain = model->Chain[j]; if (chain) for (l=0;lnResidues;l++) { res = chain->Residue[l]; if (res) for (n=0;nnAtoms;n++) { atom = res->atom[n]; if (atom) { if (!atom->Ter) SelectObject ( atom,k1,sk,nsel ); } } } } break; case STYPE_RESIDUE : for (j=0;jnChains;j++) { chain = model->Chain[j]; if (chain) for (l=0;lnResidues;l++) { res = chain->Residue[j]; if (res) SelectObject ( res,k1,sk,nsel ); } } break; case STYPE_CHAIN : for (j=0;jnChains;j++) { chain = model->Chain[j]; if (chain) SelectObject (chain,k1,sk,nsel); } break; case STYPE_MODEL : SelectObject ( model,k1,sk,nsel ); default : ; } } break; default : ; } if (selKey==SKEY_AND) for (i=0;iXadMask ( Mask[k1] ); MakeSelIndex ( selHnd1,selType,nsel ); } void CMMDBSelManager::SelectProperty ( int selHnd, // must be obtained from NewSelection() int propKey, // property key: 0 Solvent 1 Aminoacid int selType, // selection type STYPE_XXXXX int selKey // selection key ) { PCModel model; PCChain chain; PCResidue res; int i,k,selHnd1,sk,nsel, m,c,r; Boolean doSelect; if ((selHnd<=0) || (selHnd>nSelections) || (nAtoms<=0)) return; k = selHnd-1; if ((SelType[k]==STYPE_UNDEFINED) || (selKey==SKEY_NEW)) SelType[k] = selType; else if (SelType[k]!=selType) return; if (selType!=STYPE_RESIDUE) { selHnd1 = NewSelection(); if ((selKey==SKEY_AND) || (selKey==SKEY_CLR)) Select ( selHnd1,STYPE_RESIDUE,selHnd,SKEY_NEW ); } else selHnd1 = selHnd; k = selHnd1-1; SelType[k] = STYPE_RESIDUE; sk = selKey; switch (selKey) { case SKEY_NEW : for (i=0;iRemoveMask ( Mask[k] ); nSelItems[k] = 0; sk = SKEY_OR; nsel = 0; break; case SKEY_OR : if (nSelItems[k]==0) sk = SKEY_NEW; nsel = nSelItems[k]; break; case SKEY_AND : if (nSelItems[k]==0) return; sk = SKEY_XAND; nsel = 0; break; case SKEY_XOR : nsel = nSelItems[k]; break; case SKEY_CLR : nsel = nSelItems[k]; if (nsel<=0) return; break; default : return; } if ((selKey==SKEY_AND) || (selKey==SKEY_CLR)) { for (i=0;iisSolvent(); break; case SELPROP_Aminoacid : doSelect = res->isAminoacid(); break; case SELPROP_Nucleotide : doSelect = res->isNucleotide(); break; case SELPROP_Sugar : doSelect = res->isSugar(); break; case SELPROP_ModRes : doSelect = res->isModRes(); break; default : doSelect = False; } if (doSelect) SelectObject ( res,k,sk,nsel ); } } if (selKey==SKEY_AND) for (i=0;iXadMask ( Mask[k] ); } else { for (m=0;mnChains;c++) { chain = model->Chain[c]; if (chain) { for (r=0;rnResidues;r++) { res = chain->Residue[r]; if (res) { switch (propKey) { case SELPROP_Solvent : doSelect = res->isSolvent(); break; case SELPROP_Aminoacid : doSelect = res->isAminoacid(); break; case SELPROP_Nucleotide : doSelect = res->isNucleotide(); break; case SELPROP_Sugar : doSelect = res->isSugar(); break; case SELPROP_ModRes : doSelect = res->isModRes(); break; default : doSelect = False; } if (doSelect) SelectObject ( res,k,sk,nsel ); } } } } } } } MakeSelIndex ( selHnd1,STYPE_RESIDUE,nsel ); if (selType!=STYPE_RESIDUE) { Select ( selHnd,selType,selHnd1,SKEY_NEW ); DeleteSelection ( selHnd1 ); } } void CMMDBSelManager::SelectUDD ( int selHnd, // must be obtained from NewSelection() int selType, // selection type STYPE_XXXXX int UDDhandle, // UDD handle int selMin, // lower selection boundary int selMax, // upper selection boundary int selKey // selection key ) { PCModel model; PCChain chain; PCResidue res; PCAtom atom; int i,k,sk,nsel,iudd, n,c,r,a; Boolean selAND; k = selHnd-1; sk = selKey; if ((SelType[k]==STYPE_UNDEFINED) || (selKey==SKEY_NEW)) SelType[k] = selType; else if (SelType[k]!=selType) return; if ((selHnd<=0) || (selHnd>nSelections)) return; switch (selType) { case STYPE_ATOM : if ((UDDhandle & UDRF_ATOM)==0) return; break; case STYPE_RESIDUE : if ((UDDhandle & UDRF_RESIDUE)==0) return; break; case STYPE_CHAIN : if ((UDDhandle & UDRF_CHAIN)==0) return; break; case STYPE_MODEL : if ((UDDhandle & UDRF_MODEL)==0) return; break; default : return; } // if something goes wrong, sk should be assigned SKEY_OR if // selKey is set to SKEY_NEW or SKEY_OR below switch (selKey) { case SKEY_NEW : for (i=0;iRemoveMask ( Mask[k] ); nSelItems[k] = 0; nsel = 0; break; case SKEY_OR : if (nSelItems[k]==0) sk = SKEY_NEW; nsel = nSelItems[k]; break; case SKEY_AND : if (nSelItems[k]==0) return; nsel = 0; break; case SKEY_XOR : nsel = nSelItems[k]; break; case SKEY_CLR : nsel = nSelItems[k]; if (nsel<=0) return; break; default : return; } selAND = (selKey==SKEY_AND); for (n=0;ngetUDData ( UDDhandle,iudd ); if ((selMin<=iudd) && (iudd<=selMax)) SelectObject ( model,k,sk,nsel ); else if (selAND) model->RemoveMask ( Mask[k] ); } else { for (c=0;cnChains;c++) { chain = model->Chain[c]; if (chain) { // again check for safety if (selType==STYPE_CHAIN) { chain->getUDData ( UDDhandle,iudd ); if ((selMin<=iudd) && (iudd<=selMax)) SelectObject ( chain,k,sk,nsel ); else if (selAND) chain->RemoveMask ( Mask[k] ); } else { for (r=0;rnResidues;r++) { res = chain->Residue[r]; if (res) { if (selType==STYPE_RESIDUE) { res->getUDData ( UDDhandle,iudd ); if ((selMin<=iudd) && (iudd<=selMax)) SelectObject ( res,k,sk,nsel ); else if (selAND) res->RemoveMask ( Mask[k] ); } else { for (a=0;anAtoms;a++) { atom = res->atom[a]; if (atom) { if (!atom->Ter) { atom->getUDData ( UDDhandle,iudd ); if ((selMin<=iudd) && (iudd<=selMax)) SelectObject ( atom,k,sk,nsel ); else if (selAND) atom->RemoveMask ( Mask[k] ); } } } } } } } } } } } } MakeSelIndex ( selHnd,selType,nsel ); } void CMMDBSelManager::SelectUDD ( int selHnd, // must be obtained from NewSelection() int selType, // selection type STYPE_XXXXX int UDDhandle, // UDD handle realtype selMin, // lower selection boundary realtype selMax, // upper selection boundary int selKey // selection key ) { PCModel model; PCChain chain; PCResidue res; PCAtom atom; realtype rudd; int i,k,sk,nsel, n,c,r,a; Boolean selAND; k = selHnd-1; sk = selKey; if ((SelType[k]==STYPE_UNDEFINED) || (selKey==SKEY_NEW)) SelType[k] = selType; else if (SelType[k]!=selType) return; if ((selHnd<=0) || (selHnd>nSelections)) return; switch (selType) { case STYPE_ATOM : if ((UDDhandle & UDRF_ATOM)==0) return; break; case STYPE_RESIDUE : if ((UDDhandle & UDRF_RESIDUE)==0) return; break; case STYPE_CHAIN : if ((UDDhandle & UDRF_CHAIN)==0) return; break; case STYPE_MODEL : if ((UDDhandle & UDRF_MODEL)==0) return; break; default : return; } // if something goes wrong, sk should be assigned SKEY_OR if // selKey is set to SKEY_NEW or SKEY_OR below switch (selKey) { case SKEY_NEW : for (i=0;iRemoveMask ( Mask[k] ); nSelItems[k] = 0; nsel = 0; break; case SKEY_OR : if (nSelItems[k]==0) sk = SKEY_NEW; nsel = nSelItems[k]; break; case SKEY_AND : if (nSelItems[k]==0) return; nsel = 0; break; case SKEY_XOR : nsel = nSelItems[k]; break; case SKEY_CLR : nsel = nSelItems[k]; if (nsel<=0) return; break; default : return; } selAND = (selKey==SKEY_AND); for (n=0;ngetUDData ( UDDhandle,rudd ); if ((selMin<=rudd) && (rudd<=selMax)) SelectObject ( model,k,sk,nsel ); else if (selAND) model->RemoveMask ( Mask[k] ); } else { for (c=0;cnChains;c++) { chain = model->Chain[c]; if (chain) { // again check for safety if (selType==STYPE_CHAIN) { chain->getUDData ( UDDhandle,rudd ); if ((selMin<=rudd) && (rudd<=selMax)) SelectObject ( chain,k,sk,nsel ); else if (selAND) chain->RemoveMask ( Mask[k] ); } else { for (r=0;rnResidues;r++) { res = chain->Residue[r]; if (res) { if (selType==STYPE_RESIDUE) { res->getUDData ( UDDhandle,rudd ); if ((selMin<=rudd) && (rudd<=selMax)) SelectObject ( res,k,sk,nsel ); else if (selAND) res->RemoveMask ( Mask[k] ); } else { for (a=0;anAtoms;a++) { atom = res->atom[a]; if (atom) { if (!atom->Ter) { atom->getUDData ( UDDhandle,rudd ); if ((selMin<=rudd) && (rudd<=selMax)) SelectObject ( atom,k,sk,nsel ); else if (selAND) atom->RemoveMask ( Mask[k] ); } } } } } } } } } } } } MakeSelIndex ( selHnd,selType,nsel ); } Boolean selSUDD ( cpstr sudd, cpstr selStr, int cmpRule, int ssLen ) { if (!sudd) return False; switch (cmpRule) { case UDSCR_LT : return (strcmp(sudd,selStr)<0); case UDSCR_LE : return (strcmp(sudd,selStr)<=0); case UDSCR_EQ : return (strcmp(sudd,selStr)==0); case UDSCR_NE : return (strcmp(sudd,selStr)!=0); case UDSCR_GE : return (strcmp(sudd,selStr)>=0); case UDSCR_GT : return (strcmp(sudd,selStr)>=0); case UDSCR_LTcase : return (strcasecmp(sudd,selStr)<0); case UDSCR_LEcase : return (strcasecmp(sudd,selStr)<=0); case UDSCR_EQcase : return (strcasecmp(sudd,selStr)==0); case UDSCR_NEcase : return (strcasecmp(sudd,selStr)!=0); case UDSCR_GEcase : return (strcasecmp(sudd,selStr)>=0); case UDSCR_GTcase : return (strcasecmp(sudd,selStr)>=0); case UDSCR_LTn : return (strncmp(sudd,selStr,ssLen)<0); case UDSCR_LEn : return (strncmp(sudd,selStr,ssLen)<=0); case UDSCR_EQn : return (strncmp(sudd,selStr,ssLen)==0); case UDSCR_NEn : return (strncmp(sudd,selStr,ssLen)!=0); case UDSCR_GEn : return (strncmp(sudd,selStr,ssLen)>=0); case UDSCR_GTn : return (strncmp(sudd,selStr,ssLen)>=0); case UDSCR_LTncase : return (strncasecmp(sudd,selStr,ssLen)<0); case UDSCR_LEncase : return (strncasecmp(sudd,selStr,ssLen)<=0); case UDSCR_EQncase : return (strncasecmp(sudd,selStr,ssLen)==0); case UDSCR_NEncase : return (strncasecmp(sudd,selStr,ssLen)!=0); case UDSCR_GEncase : return (strncasecmp(sudd,selStr,ssLen)>=0); case UDSCR_GTncase : return (strncasecmp(sudd,selStr,ssLen)>=0); case UDSCR_Substr : return (strstr(sudd,selStr)!=NULL); case UDSCR_NoSubstr : return (strstr(sudd,selStr)==NULL); case UDSCR_Substr1 : return (strstr(selStr,sudd)!=NULL); case UDSCR_NoSubstr1 : return (strstr(selStr,sudd)==NULL); default : return False; } } void CMMDBSelManager::SelectUDD ( int selHnd, // must be obtained from NewSelection() int selType, // selection type STYPE_XXXXX int UDDhandle, // UDD handle cpstr selStr, // selection string int cmpRule, // comparison rule int selKey // selection key ) { PCModel model; PCChain chain; PCResidue res; PCAtom atom; int i,k,sk,nsel,ssLen, n,c,r,a; Boolean selAND; k = selHnd-1; sk = selKey; if ((SelType[k]==STYPE_UNDEFINED) || (selKey==SKEY_NEW)) SelType[k] = selType; else if (SelType[k]!=selType) return; if ((selHnd<=0) || (selHnd>nSelections)) return; switch (selType) { case STYPE_ATOM : if ((UDDhandle & UDRF_ATOM)==0) return; break; case STYPE_RESIDUE : if ((UDDhandle & UDRF_RESIDUE)==0) return; break; case STYPE_CHAIN : if ((UDDhandle & UDRF_CHAIN)==0) return; break; case STYPE_MODEL : if ((UDDhandle & UDRF_MODEL)==0) return; break; default : return; } // if something goes wrong, sk should be assigned SKEY_OR if // selKey is set to SKEY_NEW or SKEY_OR below switch (selKey) { case SKEY_NEW : for (i=0;iRemoveMask ( Mask[k] ); nSelItems[k] = 0; nsel = 0; break; case SKEY_OR : if (nSelItems[k]==0) sk = SKEY_NEW; nsel = nSelItems[k]; break; case SKEY_AND : if (nSelItems[k]==0) return; nsel = 0; break; case SKEY_XOR : nsel = nSelItems[k]; break; case SKEY_CLR : nsel = nSelItems[k]; if (nsel<=0) return; break; default : return; } selAND = (selKey==SKEY_AND); ssLen = strlen ( selStr ); for (n=0;ngetUDData(UDDhandle),selStr, cmpRule,ssLen)) SelectObject ( model,k,sk,nsel ); else if (selAND) model->RemoveMask ( Mask[k] ); } else { for (c=0;cnChains;c++) { chain = model->Chain[c]; if (chain) { // again check for safety if (selType==STYPE_CHAIN) { if (selSUDD(chain->getUDData(UDDhandle),selStr, cmpRule,ssLen)) SelectObject ( chain,k,sk,nsel ); else if (selAND) chain->RemoveMask ( Mask[k] ); } else { for (r=0;rnResidues;r++) { res = chain->Residue[r]; if (res) { if (selType==STYPE_RESIDUE) { if (selSUDD(res->getUDData(UDDhandle),selStr, cmpRule,ssLen)) SelectObject ( res,k,sk,nsel ); else if (selAND) res->RemoveMask ( Mask[k] ); } else { for (a=0;anAtoms;a++) { atom = res->atom[a]; if (atom) { if (!atom->Ter) { if (selSUDD(atom->getUDData(UDDhandle),selStr, cmpRule,ssLen)) SelectObject ( atom,k,sk,nsel ); else if (selAND) atom->RemoveMask ( Mask[k] ); } } } } } } } } } } } } MakeSelIndex ( selHnd,selType,nsel ); } void CMMDBSelManager::SelectSphere ( int selHnd, // must be obtained from NewSelection() int selType, // selection type STYPE_XXXXX realtype x, // x-coordinate of the sphere's center realtype y, // y-coordinate of the sphere's center realtype z, // z-coordinate of the sphere's center realtype r, // radius of the sphere int selKey // selection key ) { // Selecting a sphere int i,k, nat,sk,nsel, im,ic,ir; realtype dx,dy,dz, r2; Boolean ASel, resSel,chainSel,modelSel,selAND; PPCAtom A; PCAtom atom; PCResidue res; PCChain chain; PCModel model; if ((selHnd<=0) || (selHnd>nSelections) || (r<=0.0)) return; k = selHnd-1; sk = selKey; A = Atom; nat = nAtoms; if ((SelType[k]==STYPE_UNDEFINED) || (selKey==SKEY_NEW)) SelType[k] = selType; else if (SelType[k]!=selType) return; // if something goes wrong, sk should be assigned SKEY_OR if // selKey is set to SKEY_NEW or SKEY_OR below switch (selKey) { case SKEY_NEW : for (i=0;iRemoveMask ( Mask[k] ); nSelItems[k] = 0; nsel = 0; break; case SKEY_OR : if (nSelItems[k]==0) sk = SKEY_NEW; nsel = nSelItems[k]; break; case SKEY_AND : nsel = 0; nat = nSelItems[k]; A = (PPCAtom)Selection[k]; break; case SKEY_XOR : nsel = nSelItems[k]; break; case SKEY_CLR : nsel = nSelItems[k]; nat = nSelItems[k]; A = (PPCAtom)Selection[k]; break; default : return; } selAND = selType==SKEY_AND; if ((nat<=0) || (!A)) return; r2 = r*r; if (selType==STYPE_ATOM) { for (i=0;iTer) && (A[i]->WhatIsSet & ASET_Coordinates)) { dx = fabs(A[i]->x-x); if (dx<=r) { dy = fabs(A[i]->y-y); if (dy<=r) { dz = fabs(A[i]->z-z); if (dz<=r) { if (dx*dx+dy*dy+dz*dz<=r2) { ASel = True; SelectAtom ( A[i],k,sk,nsel ); } } } } } if (!ASel) A[i]->RemoveMask ( Mask[k] ); } } else { for (im=0;imnChains;ic++) { chain = model->Chain[ic]; if (chain) { chainSel = False; for (ir=0;irnResidues;ir++) { res = chain->Residue[ir]; if (res) { resSel = False; for (i=0;inAtoms;i++) { atom = res->atom[i]; if (atom) { ASel = False; if ((!atom->Ter) && (atom->WhatIsSet & ASET_Coordinates)) { dx = fabs(atom->x-x); if (dx<=r) { dy = fabs(atom->y-y); if (dy<=r) { dz = fabs(atom->z-z); if (dz<=r) { if (dx*dx+dy*dy+dz*dz<=r2) { SelectObject ( selType,atom,k,sk,nsel ); ASel = True; resSel = True; chainSel = True; modelSel = True; } } } } } if (ASel) break; // selType>=STYPE_RESIDUE } } if ((!resSel) && selAND && (selType==STYPE_RESIDUE)) res->RemoveMask ( Mask[k] ); if (chainSel && (selType>STYPE_RESIDUE)) break; } } if ((!chainSel) && selAND && (selType==STYPE_CHAIN)) chain->RemoveMask ( Mask[k] ); if (modelSel && (selType>STYPE_CHAIN)) break; } } if ((!modelSel) && selAND && (selType==STYPE_MODEL)) model->RemoveMask ( Mask[k] ); } } } MakeSelIndex ( selHnd,selType,nsel ); } void CMMDBSelManager::SelectCylinder ( int selHnd, // must be obtained from NewSelection() int selType, // selection type STYPE_XXXXX realtype x1, // x-coordinate of the cylinder axis' 1st end realtype y1, // y-coordinate of the cylinder axis' 1st end realtype z1, // z-coordinate of the cylinder axis' 1st end realtype x2, // x-coordinate of the cylinder axis' 2nd end realtype y2, // y-coordinate of the cylinder axis' 2nd end realtype z2, // z-coordinate of the cylinder axis' 2nd end realtype r, // radius of the cylinder int selKey // selection key ) { // // Selecting a cylinder // // Method : given a line running through (x1,y1,z1) to (x2,y2,z2) on, // a point (x,y,z) is then projected on it at distance // // c1 = (c^2-a^2+b^2)/(2c), // // from (x1,y1,z1), where // 'a' is the distance between (x,y,z) and (x2,y2,z2) // 'b' is the distance between (x,y,z) and (x1,y1,z1) // 'c' is the distance between (x1,y1,z1) and (x2,y2,z2). // The distance between point (x,y,z) and line is determined as // // h^2 = b^2 - c1^2 // // If c1>=0 and c1<=c and h^2<=r^2 then point (x,y,z) is inside // a cylinder of radius 'r' with axis running from point // (x1,y1,z1) to (x2,y2,z2). // int i,k, nat,sk,nsel, im,ic,ir; realtype dx,dy,dz, c,dc,c1,c2, a2,b2, r2; Boolean resSel,chainSel,modelSel,selAND; PPCAtom A; PCAtom atom; PCResidue res; PCChain chain; PCModel model; if ((selHnd<=0) || (selHnd>nSelections) || (r<=0.0)) return; dx = x1-x2; dy = y1-y2; dz = z1-z2; c2 = dx*dx + dy*dy + dz*dz; if (c2<=0.0) return; c = sqrt(c2); dc = 2.0*c; r2 = r*r; k = selHnd-1; sk = selKey; A = Atom; nat = nAtoms; if ((SelType[k]==STYPE_UNDEFINED) || (selKey==SKEY_NEW)) SelType[k] = selType; else if (SelType[k]!=selType) return; // if something goes wrong, sk should be assigned SKEY_OR if // selKey is set to SKEY_NEW or SKEY_OR below switch (selKey) { case SKEY_NEW : for (i=0;iRemoveMask ( Mask[k] ); nSelItems[k] = 0; nsel = 0; break; case SKEY_OR : if (nSelItems[k]==0) sk = SKEY_NEW; nsel = nSelItems[k]; break; case SKEY_AND : nsel = 0; nat = nSelItems[k]; A = (PPCAtom)Selection[k]; break; case SKEY_XOR : nsel = nSelItems[k]; break; case SKEY_CLR : nsel = nSelItems[k]; nat = nSelItems[k]; A = (PPCAtom)Selection[k]; break; default : return; } selAND = selType==SKEY_AND; if ((nat<=0) || (!A)) return; if (selType==STYPE_ATOM) { for (i=0;iTer) && (A[i]->WhatIsSet & ASET_Coordinates)) { dx = fabs(A[i]->x-x1); dy = fabs(A[i]->y-y1); dz = fabs(A[i]->z-z1); a2 = dx*dx + dy*dy + dz*dz; dx = fabs(A[i]->x-x2); dy = fabs(A[i]->y-y2); dz = fabs(A[i]->z-z2); b2 = dx*dx + dy*dy + dz*dz; c1 = (c2-a2+b2)/dc; if ((0.0<=c1) && (c1<=c) && (b2-c1*c1<=r2)) SelectAtom ( A[i],k,sk,nsel ); else if (sk==SKEY_AND) A[i]->RemoveMask ( Mask[k] ); } } } else { for (im=0;imnChains;ic++) { chain = model->Chain[ic]; if (chain) { chainSel = False; for (ir=0;irnResidues;ir++) { res = chain->Residue[ir]; if (res) { resSel = False; for (i=0;inAtoms;i++) { atom = res->atom[i]; if (atom) { if ((!atom->Ter) && (atom->WhatIsSet & ASET_Coordinates)) { dx = fabs(atom->x-x1); dy = fabs(atom->y-y1); dz = fabs(atom->z-z1); a2 = dx*dx + dy*dy + dz*dz; dx = fabs(atom->x-x2); dy = fabs(atom->y-y2); dz = fabs(atom->z-z2); b2 = dx*dx + dy*dy + dz*dz; c1 = (c2-a2+b2)/dc; if ((0.0<=c1) && (c1<=c) && (b2-c1*c1<=r2)) { SelectObject ( selType,atom,k,sk,nsel ); resSel = True; chainSel = True; modelSel = True; break; // selType>=STYPE_RESIDUE } } } } if ((!resSel) && selAND && (selType==STYPE_RESIDUE)) res->RemoveMask ( Mask[k] ); if (chainSel && (selType>STYPE_RESIDUE)) break; } } if ((!chainSel) && selAND && (selType==STYPE_CHAIN)) chain->RemoveMask ( Mask[k] ); if (modelSel && (selType>STYPE_CHAIN)) break; } } if ((!modelSel) && selAND && (selType==STYPE_MODEL)) model->RemoveMask ( Mask[k] ); } } } MakeSelIndex ( selHnd,selType,nsel ); } void CMMDBSelManager::SelectSlab ( int selHnd, // must be obtained from NewSelection() int selType, // selection type STYPE_XXXXX realtype a, // a-parameter of the plane ax+by+cz=d realtype b, // b-parameter of the plane ax+by+cz=d realtype c, // c-parameter of the plane ax+by+cz=d realtype d, // d-parameter of the plane ax+by+cz=d realtype r, // distance to the plane int selKey // selection key ) { // // Selecting all atoms on a given distance from a plane // // Method : the distance between a point (x0,y0,z0) and a plane // defined by equation // // a*x + b*y + c*z = d // // is found as // // h = (d-a*x0-b*y0-c*z0)/sqrt(a^2+b^2+c^2) // // If |h|nSelections) || (r<=0.0)) return; v = sqrt(a*a + b*b + c*c); if (v<=0.0) return; k = selHnd-1; sk = selKey; A = Atom; nat = nAtoms; if ((SelType[k]==STYPE_UNDEFINED) || (selKey==SKEY_NEW)) SelType[k] = selType; else if (SelType[k]!=selType) return; // if something goes wrong, sk should be assigned SKEY_OR if // selKey is set to SKEY_NEW or SKEY_OR below switch (selKey) { case SKEY_NEW : for (i=0;iRemoveMask ( Mask[k] ); nSelItems[k] = 0; nsel = 0; break; case SKEY_OR : if (nSelItems[k]==0) sk = SKEY_NEW; nsel = nSelItems[k]; break; case SKEY_AND : nsel = 0; nat = nSelItems[k]; A = (PPCAtom)Selection[k]; break; case SKEY_XOR : nsel = nSelItems[k]; break; case SKEY_CLR : nsel = nSelItems[k]; nat = nSelItems[k]; A = (PPCAtom)Selection[k]; break; default : return; } selAND = selType==SKEY_AND; if ((nat<=0) || (!A)) return; if (selType==STYPE_ATOM) { for (i=0;iTer) && (A[i]->WhatIsSet & ASET_Coordinates)) { h = fabs(d-a*A[i]->x-b*A[i]->y-c*A[i]->z)/v; if (h<=r) SelectAtom ( A[i],k,sk,nsel ); else if (sk==SKEY_AND) A[i]->RemoveMask ( Mask[k] ); } } } else { for (im=0;imnChains;ic++) { chain = model->Chain[ic]; if (chain) { chainSel = False; for (ir=0;irnResidues;ir++) { res = chain->Residue[ir]; if (res) { resSel = False; for (i=0;inAtoms;i++) { atom = res->atom[i]; if (atom) { if ((!atom->Ter) && (atom->WhatIsSet & ASET_Coordinates)) { h = fabs(d-a*A[i]->x-b*A[i]->y-c*A[i]->z)/v; if (h<=r) { SelectObject ( selType,atom,k,sk,nsel ); resSel = True; chainSel = True; modelSel = True; break; // selType>=STYPE_RESIDUE } } } } if ((!resSel) && selAND && (selType==STYPE_RESIDUE)) res->RemoveMask ( Mask[k] ); if (chainSel && (selType>STYPE_RESIDUE)) break; } } if ((!chainSel) && selAND && (selType==STYPE_CHAIN)) chain->RemoveMask ( Mask[k] ); if (modelSel && (selType>STYPE_CHAIN)) break; } } if ((!modelSel) && selAND && (selType==STYPE_MODEL)) model->RemoveMask ( Mask[k] ); } } } MakeSelIndex ( selHnd,selType,nsel ); } void CMMDBSelManager::SelectNeighbours ( int selHnd, // must be obtained from NewSelection() int selType, // selection type STYPE_XXXXX PPCAtom sA, // array of already selected atoms int alen, // length of A realtype d1, // minimal distance to already selected atoms realtype d2, // maximal distance to already selected atoms int selKey // selection key ) { // Selecting all atoms on a given distance from already selected int i,j,k, dn, nx,ny,nz, nat,sk,nsel, im,ic,ir; int ix1,ix2,ix, iy1,iy2,iy, iz1,iz2,iz; realtype x,y,z, dx,dy,dz, dst, d12,d22; PPCAtom A; PCBrick B; PCAtom atom; PCResidue res; PCChain chain; PCModel model; Boolean ASel,resSel,chainSel,modelSel,selAND; if ((selHnd<=0) || (selHnd>nSelections) || (d2<=0.0) || (d2RemoveMask ( Mask[k] ); nSelItems[k] = 0; } return; } // if something goes wrong, sk should be assigned SKEY_OR if // selKey is set to SKEY_NEW or SKEY_OR below switch (selKey) { case SKEY_NEW : for (i=0;iRemoveMask ( Mask[k] ); nSelItems[k] = 0; nsel = 0; break; case SKEY_OR : if (nSelItems[k]==0) sk = SKEY_NEW; nsel = nSelItems[k]; break; case SKEY_AND : nsel = 0; nat = nSelItems[k]; A = (PPCAtom)Selection[k]; break; case SKEY_XOR : nsel = nSelItems[k]; break; case SKEY_CLR : nsel = nSelItems[k]; nat = nSelItems[k]; A = (PPCAtom)Selection[k]; break; default : return; } selAND = (sk==SKEY_AND); if ((nat<=0) || (!A)) return; MakeBricks ( sA,alen,d2*1.5 ); dn = mround(d2/brick_size)+1; if (Brick && (selType==STYPE_ATOM)) { for (i=0;iTer) { ASel = False; GetBrickCoor ( A[i],nx,ny,nz ); if (nx<0) nx++; ix1 = IMax ( 0,nx-dn ); iy1 = IMax ( 0,ny-dn ); iz1 = IMax ( 0,nz-dn ); ix2 = IMin ( nbrick_x,nx+dn+1 ); iy2 = IMin ( nbrick_y,ny+dn+1 ); iz2 = IMin ( nbrick_z,nz+dn+1 ); x = A[i]->x; y = A[i]->y; z = A[i]->z; for (ix=ix1;(ixnAtoms) && (!ASel);j++) if (B->Atom[j]!=A[i]) { dx = fabs(x-B->Atom[j]->x); if (dx<=d2) { dy = fabs(y-B->Atom[j]->y); if (dy<=d2) { dz = fabs(z-B->Atom[j]->z); if (dz<=d2) { dst = dx*dx+dy*dy+dz*dz; if ((dst>=d12) && (dst<=d22)) { ASel = True; SelectAtom ( A[i],k,sk,nsel ); } } } } } } if ((!ASel) && selAND) A[i]->RemoveMask ( Mask[k] ); } } } else if (Brick) { for (im=0;imnChains;ic++) { chain = model->Chain[ic]; if (chain) { chainSel = False; for (ir=0;irnResidues;ir++) { res = chain->Residue[ir]; if (res) { resSel = False; for (i=0;(inAtoms) && (!resSel);i++) { atom = res->atom[i]; if (atom) { if ((!atom->Ter) && (atom->WhatIsSet & ASET_Coordinates)) { GetBrickCoor ( atom,nx,ny,nz ); if (nx<0) nx++; ix1 = IMax ( 0,nx-dn ); iy1 = IMax ( 0,ny-dn ); iz1 = IMax ( 0,nz-dn ); ix2 = IMin ( nbrick_x,nx+dn+1 ); iy2 = IMin ( nbrick_y,ny+dn+1 ); iz2 = IMin ( nbrick_z,nz+dn+1 ); x = atom->x; y = atom->y; z = atom->z; for (ix=ix1;(ixnAtoms) && (!resSel);j++) if (B->Atom[j]!=atom) { dx = fabs(x-B->Atom[j]->x); if (dx<=d2) { dy = fabs(y-B->Atom[j]->y); if (dy<=d2) { dz = fabs(z-B->Atom[j]->z); if (dz<=d2) { dst = dx*dx+dy*dy+dz*dz; if ((dst>=d12) && (dst<=d22)) { SelectObject ( selType, atom,k,sk,nsel ); resSel = True; chainSel = True; modelSel = True; } } } } } } } } } if ((!resSel) && selAND && (selType==STYPE_RESIDUE)) res->RemoveMask ( Mask[k] ); if (chainSel && (selType>STYPE_RESIDUE)) break; } } if ((!chainSel) && selAND && (selType==STYPE_CHAIN)) chain->RemoveMask ( Mask[k] ); if (modelSel && (selType>STYPE_CHAIN)) break; } } if ((!modelSel) && selAND && (selType==STYPE_MODEL)) model->RemoveMask ( Mask[k] ); } } } MakeSelIndex ( selHnd,selType,nsel ); } int TakeChainID ( pstr & p, pstr chainID ) { int RC,k; chainID[0] = char(0); if (*p) { RC = 0; if (*p==':') { // starts with colon <=> empty chain ID chainID[0] = char(0); p++; // advance to residue number } else if (p[1]==':') { // second symbol is colon <=> regular chain ID chainID[0] = *p; chainID[1] = char(0); p++; p++; // advance to residue number } else if (*p=='\'') { // starts with a strip <=> assume empty chain ID chainID[0] = char(0); p++; if (*p=='\'') { // closing strip must be followed by colon p++; if (*p!=':') RC = -1; } else { // no concluding strip <=> could be a strip chain ID, // although this must be captured by 2nd "if" chainID[0] = '\''; chainID[1] = char(0); // assume that residue number is following the strip } } else if ((int(*p)>=int('0')) && (int(*p)<=int('9'))) { // a digit without following semicolon looks very much // like residue number with unspecified empty chain ID chainID[0] = char(0); // assume that p already points on residue number } else { // assume a long chain ID k = 0; while (*p && (*p!=':') && (k<(int)sizeof(ChainID)-1)) { chainID[k++] = *p; p++; } if (*p==':') { chainID[k] = char(0); } else { // a mistake chainID[0] = char(0); RC = -1; } } while (*p==' ') p++; } else RC = 1; return RC; } int TakeResID( pstr & p, int & seqNum, pstr inscode ) { char N[100]; int i,RC; pstr endptr; RC = 1; inscode[0] = '*'; inscode[1] = char(0); seqNum = ANY_RES; if (((*p) && (int(*p)>=int('0')) && (int(*p)<=int('9'))) || (*p=='-')) { N[0] = *p; p++; i = 1; while ((*p) && (int(*p)>=int('0')) && (int(*p)<=int('9'))) { N[i++] = *p; p++; } N[i] = char(0); seqNum = mround(strtod(N,&endptr)); if ((seqNum==0) && (endptr==N)) RC = -1; else { RC = 0; if ((*p) && (*p!='-') && (*p!=',') && (*p!=' ')) { inscode[0] = *p; inscode[1] = char(0); p++; } else inscode[0] = char(0); if ((*p=='-') || (*p==',')) p++; } while (*p==' ') p++; } return RC; } int CMMDBSelManager::SelectDomain ( int selHnd , cpstr domainRange, int selType, int selKey, int modelNo ) { // domainRange is of the following format: // "*", "(all)" - take all file // "-" - take chain without chain ID // "a:Ni-Mj,b:Kp-Lq,..." - take chain a residue number N // insertion code i to residue number M // insertion code j plus chain b // residue number K insertion code p to // residue number L insertion code q and // so on. // "a:,b:..." - take whole chains a and b and so on // "a:,b:Kp-Lq,..." - any combination of the above. ChainID chainID; InsCode insCode1,insCode2; pstr S,p; int seqNum1,seqNum2,rc,selKey1; if ((selHnd<=0) || (selHnd>nSelections)) return 1; // leave only required residues rc = 1; if (!domainRange) rc = 0; else if ((!domainRange[0]) || (domainRange[0]=='*')) rc = 0; else if (!strcasecmp(domainRange,"(all)")) rc = 0; if (!rc) { // select all Select ( selHnd,selType,modelNo,"*",ANY_RES,"*",ANY_RES,"*", "*","*","*","*",selKey ); return 0; } if (!strcasecmp(domainRange,"-")) { // select chain without chain ID Select ( selHnd,selType,modelNo,"",ANY_RES,"*",ANY_RES,"*", "*","*","*","*",selKey ); return 0; } S = new char[strlen(domainRange)+10]; strcpy ( S,domainRange ); DelSpaces ( S ); // UpperCase ( S ); p = S; rc = 0; selKey1 = selKey; while ((*p) && (!rc)) { if (TakeChainID(p,chainID)<0) rc = -1; else if (TakeResID(p,seqNum1,insCode1)<0) rc = -2; else if (TakeResID(p,seqNum2,insCode2)<0) rc = -3; else { Select ( selHnd,selType,modelNo,chainID, seqNum1,insCode1,seqNum2,insCode2, "*","*","*","*",selKey1 ); if (*p==',') p++; if (selKey1==SKEY_NEW) selKey1 = SKEY_OR; } } delete[] S; return rc; } int CMMDBSelManager::GetSelLength ( int selHnd ) { if ((selHnd>0) && (selHnd<=nSelections)) return nSelItems[selHnd-1]; else return 0; } void CMMDBSelManager::GetSelIndex ( int selHnd, PPCAtom & SelAtom, int & nSelAtoms ) { if ((selHnd>0) && (selHnd<=nSelections)) { if (SelType[selHnd-1]!=STYPE_ATOM) { SelAtom = NULL; nSelAtoms = 0; } else { SelAtom = (PPCAtom)Selection[selHnd-1]; nSelAtoms = nSelItems[selHnd-1]; } } else { SelAtom = NULL; nSelAtoms = 0; } } void CMMDBSelManager::GetSelIndex ( int selHnd, PPCResidue & SelResidue, int & nSelResidues ) { if ((selHnd>0) && (selHnd<=nSelections)) { if (SelType[selHnd-1]!=STYPE_RESIDUE) { SelResidue = NULL; nSelResidues = 0; } else { SelResidue = (PPCResidue)Selection[selHnd-1]; nSelResidues = nSelItems[selHnd-1]; } } else { SelResidue = NULL; nSelResidues = 0; } } void CMMDBSelManager::GetSelIndex ( int selHnd, PPCChain & SelChain, int & nSelChains ) { if ((selHnd>0) && (selHnd<=nSelections)) { if (SelType[selHnd-1]!=STYPE_CHAIN) { SelChain = NULL; nSelChains = 0; } else { SelChain = (PPCChain)Selection[selHnd-1]; nSelChains = nSelItems[selHnd-1]; } } else { SelChain = NULL; nSelChains = 0; } } void CMMDBSelManager::GetSelIndex ( int selHnd, PPCModel & SelModel, int & nSelModels ) { if ((selHnd>0) && (selHnd<=nSelections)) { if (SelType[selHnd-1]!=STYPE_MODEL) { SelModel = NULL; nSelModels = 0; } else { SelModel = (PPCModel)Selection[selHnd-1]; nSelModels = nSelItems[selHnd-1]; } } else { SelModel = NULL; nSelModels = 0; } } void CMMDBSelManager::GetAtomStatistics ( int selHnd, RSAtomStat AS ) { int i,k; AS.Init(); if ((selHnd>0) && (selHnd<=nSelections)) { k = selHnd-1; switch (SelType[k]) { case STYPE_MODEL : if (Selection[k]) for (i=0;i CalcAtomStatistics ( AS ); break; case STYPE_CHAIN : if (Selection[k]) for (i=0;i CalcAtomStatistics ( AS ); break; case STYPE_RESIDUE : if (Selection[k]) for (i=0;i CalcAtomStatistics ( AS ); break; case STYPE_ATOM : if (Selection[k]) for (i=0;i CalcAtomStatistics ( AS ); break; default : break; } } AS.Finish(); } void CMMDBSelManager::SelectAtom ( PCAtom atom, int maskNo, int selKey, int & nsel ) { Boolean ASel; ASel = atom->CheckMask ( Mask[maskNo] ); switch (selKey) { default : case SKEY_NEW : case SKEY_OR : if (!ASel) { atom->SetMask ( Mask[maskNo] ); nsel++; } break; case SKEY_AND : if (ASel) nsel++; break; case SKEY_XOR : if (ASel) { atom->RemoveMask ( Mask[maskNo] ); nsel--; } else { atom->SetMask ( Mask[maskNo] ); nsel++; } break; case SKEY_CLR : if (ASel) { atom->RemoveMask ( Mask[maskNo] ); nsel--; } } } void CMMDBSelManager::SelectObject ( int selType, PCAtom atom, int maskNo, int selKey, int & nsel ) { PCMask object; switch (selType) { default : case STYPE_UNDEFINED : return; case STYPE_ATOM : object = atom; break; case STYPE_RESIDUE : object = atom->GetResidue(); break; case STYPE_CHAIN : object = atom->GetChain (); break; case STYPE_MODEL : object = atom->GetModel (); break; } if (!object) return; SelectObject ( object,maskNo,selKey,nsel ); } void CMMDBSelManager::SelectObject ( PCMask object, int maskNo, int selKey, int & nsel ) { Boolean ASel; ASel = object->CheckMask ( Mask[maskNo] ); switch (selKey) { default : case SKEY_NEW : case SKEY_OR : if (!ASel) { object->SetMask ( Mask[maskNo] ); nsel++; } break; case SKEY_AND : if (ASel) nsel++; break; case SKEY_XOR : if (ASel) { object->RemoveMask ( Mask[maskNo] ); nsel--; } else { object->SetMask ( Mask[maskNo] ); nsel++; } break; case SKEY_CLR : if (ASel) { object->RemoveMask ( Mask[maskNo] ); nsel--; } break; case SKEY_XAND : if (ASel) { object->RemoveMask ( Mask[maskNo] ); nsel++; } } } void CMMDBSelManager::DeleteSelObjects ( int selHnd ) { PPCModel model; PPCChain chain; PPCResidue res; PPCAtom atom; int i,k,nSel; if ((selHnd>0) && (selHnd<=nSelections)) { k = selHnd-1; nSel = nSelItems[k]; switch (SelType[k]) { case STYPE_MODEL : model = (PPCModel)Selection[k]; for (i=0;i0) && (selHnd<=nSelections)) { k1 = selHnd-1; k2 = k1+1; } else { k1 = 0; k2 = nSelections; } for (k=k1;kCheckMask(Mask[k])) ns++; break; case STYPE_RESIDUE : for (n=0;nnChains;i++) { chain = model->Chain[i]; if (chain) for (j=0;jnResidues;j++) { res = chain->Residue[j]; if (res) if (res->CheckMask(Mask[k])) ns++; } } } break; case STYPE_CHAIN : for (i=0;inChains;j++) { chain = model->Chain[j]; if (chain) if (chain->CheckMask(Mask[k])) ns++; } } break; case STYPE_MODEL : for (i=0;iCheckMask(Mask[k])) ns++; break; default : ; } } else ns = nsel; if (Selection[k]) delete[] Selection[k]; if (ns>0) { Selection[k] = new PCMask[ns]; nns = 0; switch (selType) { case STYPE_ATOM : for (i=0;iCheckMask(Mask[k])) { Selection[k][nns++] = Atom[i]; if (nns>=ns) nns = ns-1; } } break; case STYPE_RESIDUE : for (n=0;nnChains;i++) { chain = model->Chain[i]; if (chain) for (j=0;jnResidues;j++) { res = chain->Residue[j]; if (res) if (res->CheckMask(Mask[k])) { Selection[k][nns++] = res; if (nns>=ns) nns = ns-1; } } } } break; case STYPE_CHAIN : for (i=0;inChains;j++) { chain = model->Chain[j]; if (chain) if (chain->CheckMask(Mask[k])) { Selection[k][nns++] = chain; if (nns>=ns) nns = ns-1; } } } break; case STYPE_MODEL : for (i=0;iCheckMask(Mask[k])) { Selection[k][nns++] = Model[i]; if (nns>=ns) nns = ns-1; } break; default : ; } } else Selection[k] = NULL; nSelItems[k] = ns; } } // ------------------- Stream functions ---------------------- void CMMDBSelManager::write ( RCFile f ) { int i; byte Version=1; f.WriteByte ( &Version ); CMMDBCoorManager::write ( f ); f.WriteInt ( &nSelections ); for (i=0;i0) { Mask = new PCMask [nSelections]; Selection = new PPCMask[nSelections]; nSelItems = new int [nSelections]; SelType = new int [nSelections]; for (i=0;i // ~~~~~~~~~ // **** Classes : CVertex ( graph vertex ) // ~~~~~~~~~ CEdge ( graph edge ) // CGraph ( structural graph ) // CMatch ( match of structural graphs ) // CGraphMatch ( CSIA algorithms for graph matching ) // // (C) E. Krissinel 2000-2012 // // When used, please cite: // // Krissinel, E. and Henrick, K. (2004) // Common subgraph isomorphism detection by backtracking search. // Software - Practice and Experience, 34, 591-607. // // ================================================================= // #ifndef __STDLIB_H #include #endif #ifndef __STRING_H #include #endif #ifndef __MMDB_Graph__ #include "mmdb_graph.h" #endif #ifndef __MMDB_Tables__ #include "mmdb_tables.h" #endif // ========================== CVertex ============================ CVertex::CVertex() : CStream() { InitVertex(); } CVertex::CVertex ( RPCStream Object ) : CStream(Object) { InitVertex(); } CVertex::CVertex ( cpstr chem_elem ) : CStream() { InitVertex(); SetVertex ( chem_elem ); } CVertex::CVertex ( int vtype ) : CStream() { InitVertex(); SetVertex ( vtype ); } CVertex::CVertex ( int vtype, cpstr vname ) : CStream() { InitVertex(); SetVertex ( vtype,vname ); } CVertex::CVertex ( cpstr chem_elem, cpstr vname ) : CStream() { InitVertex (); SetVertex ( chem_elem ); CreateCopy ( name,vname ); } CVertex::~CVertex() { if (name) delete[] name; } void CVertex::InitVertex() { name = NULL; type = 0; type_ext = 0; property = 0; id = 0; user_id = 0; } void CVertex::SetVertex ( cpstr chem_elem ) { // This function generates vertex type according to a chemical // element name passed in chem_elem. // // The element type has the following meaning: // // 0xCHSSTTTT // // where // T - resreved for elemenmt type // S - resreved for symmetry relief // H - reserved for hydrogen bonds // C - resreved for chirality flags // // Note that when more than 2 symbols are used for chemical element // name (custom use), fields S may be reallocated for element type // and then symmetry relief becomes impossible. // CreateCopy ( name,chem_elem ); type = getElementNo ( chem_elem ); if (type==ELEMENT_UNKNOWN) { type = 0; if (name[0]) { type = (int)name[0]; if (name[1]) { type = type*256+(int)name[1]; if (name[2]) type = type*256+(int)name[2]; } } type += nElementNames; } } void CVertex::SetVertex ( int vtype ) { // This function sets vertex type. See comments above for // the general rule for vertex types implied by this code. char N[50]; int type0; type = vtype; type0 = vtype & TYPE_MASK; if ((type0>=1) && (type0<=nElementNames)) CreateCopy ( name,ElementName[type0-1] ); else { sprintf ( N,"%i",type ); CreateCopy ( name,N ); } } void CVertex::SetType ( int vtype ) { type = vtype; } void CVertex::SetTypeExt ( int typeExt ) { type_ext = typeExt; } void CVertex::SetVertex ( int vtype, cpstr vname ) { type = vtype; CreateCopy ( name,vname ); } void CVertex::SetName ( cpstr vname ) { CreateCopy ( name,vname ); } void CVertex::SetID ( int vid ) { id = vid; } void CVertex::SetProperty ( int vprop ) { property = vprop; } int CVertex::GetNBonds() { return ((type & HYDROGEN_BOND) >> 24); } void CVertex::AddBond() { int nb = GetNBonds()+1; type &= ~HYDROGEN_BOND; type |= nb << 24; } void CVertex::CopyNBonds ( PCVertex V ) { int nb = V->GetNBonds(); type &= ~HYDROGEN_BOND; type |= nb << 24; } void CVertex::RemoveChirality() { type &= CHIRAL_MASK; } void CVertex::LeaveChirality ( int eltype ) { // leaves chirality only on specified elements int vtype; vtype = type & CHIRAL_MASK; if (vtype!=eltype) type = vtype; } void CVertex::SaveType() { user_id = type; } void CVertex::RestoreType() { type = user_id; } void CVertex::CopyType ( PCVertex V ) { type = V->type; } void CVertex::Print ( int PKey ) { if (PKey!=0) printf ( " name type" ); else printf ( " %10s %5i",name,type ); } void CVertex::Copy ( PCVertex V ) { CreateCopy ( name,V->name ); type = V->type; type_ext = V->type_ext; property = V->property; id = V->id; user_id = V->user_id; } void CVertex::write ( RCFile f ) { int Version=2; f.WriteInt ( &Version ); f.CreateWrite ( name ); f.WriteInt ( &type ); f.WriteInt ( &property ); f.WriteInt ( &id ); f.WriteInt ( &user_id ); f.WriteInt ( &type_ext ); } void CVertex::read ( RCFile f ) { int Version; f.ReadInt ( &Version ); f.CreateRead ( name ); f.ReadInt ( &type ); f.ReadInt ( &property ); f.ReadInt ( &id ); f.ReadInt ( &user_id ); if (Version>1) f.ReadInt ( &type_ext ); else type_ext = 0; } void CVertex::mem_write ( pstr S, int & l ) { byte Version=2; ::mem_write_byte ( Version,S,l ); ::mem_write ( name ,S,l ); ::mem_write ( type ,S,l ); ::mem_write ( property,S,l ); ::mem_write ( id ,S,l ); ::mem_write ( user_id ,S,l ); ::mem_write ( type_ext,S,l ); } void CVertex::mem_read ( cpstr S, int & l ) { byte Version; ::mem_read_byte ( Version,S,l ); ::mem_read ( name ,S,l ); ::mem_read ( type ,S,l ); ::mem_read ( property,S,l ); ::mem_read ( id ,S,l ); ::mem_read ( user_id ,S,l ); ::mem_read ( type_ext,S,l ); } MakeStreamFunctions(CVertex); // =========================== CEdge ============================= CEdge::CEdge() : CStream() { InitEdge(); } CEdge::CEdge ( RPCStream Object ) : CStream(Object) { InitEdge(); } CEdge::CEdge ( int vx1, int vx2, int btype ) { InitEdge(); SetEdge ( vx1,vx2,btype ); } CEdge::~CEdge() {} void CEdge::InitEdge() { v1 = 0; v2 = 0; type = 0; property = 0; } #define NofBondTypes 4 static pstr BondType[NofBondTypes+1] = { pstr("SING"), pstr("DOUB"), pstr("AROM"), pstr("TRIP"), pstr("") // should be here for safety }; void CEdge::SetEdge ( int vx1, int vx2, cpstr btype ) { v1 = vx1; v2 = vx2; type = 0; while (type=NofBondTypes) { type = 0; if (btype[0]) type = (int)btype[0]; if (btype[1]) type = type*16+(int)btype[1]; if (btype[2]) type = type*16+(int)btype[2]; type += NofBondTypes; } type++; } void CEdge::SetEdge ( int vx1, int vx2, int btype ) { v1 = vx1; v2 = vx2; type = btype; } void CEdge::SetType ( int btype ) { type = btype; } void CEdge::SetProperty ( int eprop ) { property = eprop; } void CEdge::SaveType() { property = type; } void CEdge::RestoreType() { type = property; } void CEdge::Print ( int PKey ) { if (PKey!=0) printf ( " v1 v2 type" ); else printf ( " %5i %5i %5i",v1,v2,type ); } void CEdge::Copy ( PCEdge G ) { v1 = G->v1; v2 = G->v2; type = G->type; property = G->property; } void CEdge::write ( RCFile f ) { int Version=1; f.WriteInt ( &Version ); f.WriteInt ( &v1 ); f.WriteInt ( &v2 ); f.WriteInt ( &type ); f.WriteInt ( &property ); } void CEdge::read ( RCFile f ) { int Version; f.ReadInt ( &Version ); f.ReadInt ( &v1 ); f.ReadInt ( &v2 ); f.ReadInt ( &type ); f.ReadInt ( &property ); } void CEdge::mem_write ( pstr S, int & l ) { byte Version=1; ::mem_write_byte ( Version,S,l ); ::mem_write ( v1 ,S,l ); ::mem_write ( v2 ,S,l ); ::mem_write ( type ,S,l ); ::mem_write ( property,S,l ); } void CEdge::mem_read ( cpstr S, int & l ) { byte Version; ::mem_read_byte ( Version,S,l ); ::mem_read ( v1 ,S,l ); ::mem_read ( v2 ,S,l ); ::mem_read ( type ,S,l ); ::mem_read ( property,S,l ); } MakeStreamFunctions(CEdge); // ========================== CGraph ============================ CGraph::CGraph() : CStream() { InitGraph(); } CGraph::CGraph ( PCResidue R, cpstr altLoc ) : CStream() { InitGraph(); MakeGraph ( R,altLoc ); } CGraph::CGraph ( RPCStream Object ) : CStream(Object) { InitGraph(); } CGraph::~CGraph() { FreeMemory(); } void CGraph::InitGraph() { nVAlloc = 0; nEAlloc = 0; nGAlloc = 0; nVertices = 0; nEdges = 0; nAllVertices = 0; nAllEdges = 0; Vertex = NULL; Edge = NULL; graph = NULL; name = NULL; CreateCopy ( name,pstr("UNNAMED") ); } void CGraph::FreeMemory() { int i; if (Vertex) { for (i=0;i=nVAlloc) { nVAlloc += AllocPortion; V1 = new PCVertex[nVAlloc]; for (i=0;i0) FreeMemory(); Vertex = V; nVertices = vlen; nAllVertices = vlen; nVAlloc = vlen; } int CGraph::GetVertexID ( int vertexNo ) { if ((vertexNo>0) && (vertexNo<=nAllVertices)) return Vertex[vertexNo-1]->GetID(); else return MinInt4; } int CGraph::GetNBondedVertices ( int vertexNo ) { if ((vertexNo>0) && (vertexNo<=nAllVertices)) { if (Vertex[vertexNo-1]) return Vertex[vertexNo-1]->GetNBonds(); } return 0; } int CGraph::GetBondedVertexID ( int vertexNo, int bond_vx_type, int bondNo ) { int i,k, v1,v2; if ((vertexNo>0) && (vertexNo<=nAllVertices)) { if (Vertex[vertexNo-1]) { if (Vertex[vertexNo-1]->GetNBonds()>=bondNo) { k = 0; for (i=0;(iv1; v2 = Edge[i]->v2; if ((v1==vertexNo) && ((Vertex[v2-1]->type & TYPE_MASK)==bond_vx_type) && (Vertex[v2-1]->GetNBonds()==bondNo)) k = v2; if ((v2==vertexNo) && ((Vertex[v1-1]->type & TYPE_MASK)==bond_vx_type) && (Vertex[v2-1]->GetNBonds()==bondNo)) k = v1; } if (k) return Vertex[k-1]->GetID(); } } } return MinInt4; } PCVertex CGraph::GetVertex ( int vertexNo ) { if ((vertexNo>0) && (vertexNo<=nAllVertices)) return Vertex[vertexNo-1]; else return NULL; } int CGraph::GetVertexNo ( cpstr vname ) { int i,k; k = 0; if (vname) for (i=0;(iname)) k = i+1; return k; } PCEdge CGraph::GetEdge ( int edgeNo ) { if ((edgeNo>0) && (edgeNo<=nAllEdges)) return Edge[edgeNo-1]; else return NULL; } void CGraph::AddEdge ( PCEdge G ) { int i; PPCEdge G1; if (nAllEdges>=nEAlloc) { nEAlloc += AllocPortion; G1 = new PCEdge[nEAlloc]; for (i=0;i0) FreeMemory(); Edge = G; nEdges = glen; nAllEdges = glen; nEAlloc = glen; } void CGraph::GetVertices ( PPCVertex & V, int & nV ) { V = Vertex; nV = nVertices; } void CGraph::GetEdges ( PPCEdge & E, int & nE ) { E = Edge; nE = nEdges; } int CGraph::MakeGraph ( PCResidue R, cpstr altLoc ) { int i,j, a1,a2,e1,e2, nAltLocs,alflag, rc; Boolean B; rvector occupancy; AltLoc aLoc; PAltLoc aL; realtype dx,dy,dz, sr; PCEdge G; rc = MKGRAPH_Ok; // reset graph FreeMemory(); occupancy = NULL; aL = NULL; R->GetAltLocations ( nAltLocs,aL,occupancy,alflag ); if (nAltLocs<=0) return MKGRAPH_NoAtoms; if (altLoc) strcpy ( aLoc,altLoc ); else aLoc[0] = char(0); if (nAltLocs<=1) { // Only one alt code is there, check if it is what was ordered if (strcmp(aLoc,aL[0])) { rc = MKGRAPH_ChangedAltLoc; strcpy ( aLoc,aL[0] ); } } else if ((alflag & ALF_Mess) || ((alflag & ALF_NoEmptyAltLoc) && (!aLoc[0]))) { // There is a mess in the residue alt codes, or empty alt code // does not designate a conformation but ordered. In this // situation build graph for maximal-occupancy conformation // and store its altLoc in aLoc. rc = MKGRAPH_MaxOccupancy; dx = -2.0; for (i=0;idx)) { dx = occupancy[i]; strcpy ( aLoc,aL[i] ); } } SetName ( R->name ); nVAlloc = R->nAtoms; // upper estimate for vertices to allocate if (nVAlloc<=0) { if (aL) delete[] aL; FreeVectorMemory ( occupancy,0 ); return MKGRAPH_NoAtoms; } // allocate vertex array Vertex = new PCVertex[nVAlloc]; for (i=0;inAtoms;i++) if (R->atom[i]) { if (!R->atom[i]->Ter) { if (nAltLocs>1) { // This is a many-altcode residue. aLoc contains the altcode // that has to be included. Check on it: B = !strcmp(aLoc,R->atom[i]->altLoc); if ((!B) && (!R->atom[i]->altLoc[0])) { // We got a non-aLoc code that is an "empty-altcode". // Check if this atom has the altcode that we need. for (j=i+1;(jnAtoms) && (!B);j++) if (R->atom[j]) { if ((!R->atom[j]->Ter) && (!strcmp(R->atom[j]->name,R->atom[i]->name))) B = !strcmp(aLoc,R->atom[j]->altLoc); } // if altcode=aLoc is not there for the atom (B is set // False) then we take its "empty-code" location B = !B; } } else B = True; if (B) { Vertex[nVertices] = new CVertex ( R->atom[i]->element, R->atom[i]->name ); Vertex[nVertices]->id = nVertices; Vertex[nVertices]->user_id = i; nVertices++; } } } if (nVertices<=0) { if (aL) delete[] aL; FreeVectorMemory ( occupancy,0 ); return MKGRAPH_NoAtoms; } // make edges nEAlloc = 3*nVertices; Edge = new PCEdge[nEAlloc]; for (i=0;iuser_id; e1 = Vertex[i]->type; if (e1>nElementNames) e1 = 6; e1--; for (j=i+1;juser_id; e2 = Vertex[j]->type; if (e2>nElementNames) e2 = 6; e2--; dx = R->atom[a2]->x - R->atom[a1]->x; dy = R->atom[a2]->y - R->atom[a1]->y; dz = R->atom[a2]->z - R->atom[a1]->z; // sr = CovalentRadius[e1] + CovalentRadius[e2] + 0.15; sr = CovalentRadius[e1] + CovalentRadius[e2] + 0.25; if (dx*dx+dy*dy+dz*dzid = i+1; } if (aL) delete[] aL; FreeVectorMemory ( occupancy,0 ); nAllVertices = nVertices; nAllEdges = nEdges; return rc; } int CGraph::MakeGraph ( PPCAtom atom, int nAtoms ) { PCEdge G; char atomID[100]; realtype dx,dy,dz, sr; int i,j, a1,a2,e1,e2, rc; rc = MKGRAPH_Ok; // reset graph FreeMemory(); nVAlloc = nAtoms; // upper estimate for vertices to allocate if (nVAlloc<=0) return MKGRAPH_NoAtoms; // allocate vertex array Vertex = new PCVertex[nVAlloc]; for (i=0;iTer) { Vertex[nVertices] = new CVertex ( atom[i]->element, atom[i]->GetAtomIDfmt(atomID) ); Vertex[nVertices]->user_id = i; nVertices++; } } if (nVertices<=0) { FreeMemory(); return MKGRAPH_NoAtoms; } // make edges nEAlloc = 3*nVertices; // just an inital guess Edge = new PCEdge[nEAlloc]; for (i=0;iuser_id; e1 = Vertex[i]->type; if (e1>nElementNames) e1 = 6; e1--; for (j=i+1;juser_id; e2 = Vertex[j]->type; if (e2>nElementNames) e2 = 6; e2--; dx = atom[a2]->x - atom[a1]->x; dy = atom[a2]->y - atom[a1]->y; dz = atom[a2]->z - atom[a1]->z; sr = CovalentRadius[e1] + CovalentRadius[e2] + 0.25; if (dx*dx+dy*dy+dz*dzid = i+1; } nAllVertices = nVertices; nAllEdges = nEdges; return rc; } void CGraph::MakeVertexIDs() { int i; for (i=0;iid = i+1; } void CGraph::HideType ( int bond_vx_type ) { // 1. Moves vertices bond_vx_type to the end of vertex array // 2. Moves edges to bond_vx_type vertices to the end of edge array // 3. Saves lengths of full vertex and edge arrays, and redefines // lengths to initial parts of the arrays not containing // bond_vx_type vertices. PPCEdge Edge1; PPCVertex Vertex1; int i,k,v1,v2, nEdges1,nVertices1; ivector iv; Edge1 = new PCEdge[nEdges]; Vertex1 = new PCVertex[nVertices]; GetVectorMemory ( iv,nVertices,1 ); for (i=0;iv1-1; v2 = Edge[i]->v2-1; if (Vertex[v1] && Vertex[v2]) { if ((Vertex[v1]->type & TYPE_MASK)==bond_vx_type) { Vertex[v2]->AddBond(); Vertex[v1]->CopyNBonds ( Vertex[v2] ); } if ((Vertex[v2]->type & TYPE_MASK)==bond_vx_type) { Vertex[v1]->AddBond(); Vertex[v2]->CopyNBonds ( Vertex[v1] ); } } } nVertices1 = 0; for (i=0;itype & TYPE_MASK)!=bond_vx_type) { Vertex1[nVertices1++] = Vertex[i]; iv[i+1] = nVertices1; } } k = nVertices1; for (i=0;itype & TYPE_MASK)==bond_vx_type) { Vertex1[k++] = Vertex[i]; iv[i+1] = k; } } nEdges1 = 0; for (i=0;iv1 = iv[Edge[i]->v1]; Edge[i]->v2 = iv[Edge[i]->v2]; if (((Vertex1[Edge[i]->v1-1]->type & TYPE_MASK)!=bond_vx_type) && ((Vertex1[Edge[i]->v2-1]->type & TYPE_MASK)!=bond_vx_type)) Edge1[nEdges1++] = Edge[i]; } k = nEdges1; for (i=0;iv1-1]->type & TYPE_MASK)==bond_vx_type) || ((Vertex1[Edge[i]->v2-1]->type & TYPE_MASK)==bond_vx_type)) Edge1[k++] = Edge[i]; } nAllVertices = nVertices; nAllEdges = nEdges; nVAlloc = nVertices; nEAlloc = nEdges; nVertices = nVertices1; nEdges = nEdges1; if (Vertex) delete[] Vertex; if (Edge) delete[] Edge; FreeVectorMemory ( iv,1 ); Vertex = Vertex1; Edge = Edge1; } void CGraph::ExcludeType ( int type ) { int i,k; ivector iv; GetVectorMemory ( iv,nAllVertices,1 ); k = 0; for (i=0;itype & TYPE_MASK)!=type) { if (kv1]!=0) && (iv[Edge[i]->v2]!=0)) { if (kv1 = iv[Edge[k]->v1]; Edge[k]->v2 = iv[Edge[k]->v2]; k++; } else { delete Edge[i]; Edge[i] = NULL; } nAllEdges = k; nEdges = nAllEdges; FreeVectorMemory ( iv,1 ); } void CGraph::RemoveChirality() { int i; for (i=0;iRemoveChirality(); } void CGraph::LeaveChirality ( int eltype ) { // leaves chirality for specified atom types int i; for (i=0;iLeaveChirality ( eltype ); } void CGraph::MakeSymmetryRelief ( Boolean noCO2 ) { // This function looks for groups of equivalent vertices // attached to a single vertice (e.g. chemical SO3 or // PO3 groups), and re-lables them by adding a unique // symmetry-relief number. This eliminates equivalent // matches (3! for each SO3/PO3 group), and increases // vertex diversity, which considerably speeds up matching. // The function is cheap and harmless even if such groups // of vertices are not found. // If noCO2 is True then CO2 symmetry is not releaved. ivector v,vc; int i,j,k,n,m,almask,vjtype, ctype,otype; Boolean noOxygens; otype = 0; ctype = 0; GetVectorMemory ( v ,nVertices,0 ); GetVectorMemory ( vc,nVertices,1 ); for (i=1;i<=nVertices;i++) vc[i] = 0; for (j=0;jv1>0) && (Edge[j]->v1<=nVertices)) vc[Edge[j]->v1]++; if ((Edge[j]->v2>0) && (Edge[j]->v2<=nVertices)) vc[Edge[j]->v2]++; } almask = ~ATOM_LEAVING; if (noCO2) { ctype = getElementNo ( "C" ); otype = getElementNo ( "O" ); } noOxygens = False; for (i=1;i<=nVertices;i++) if (vc[i]>1) { // vertex at more than 1 edge // v[] will list connected vertices, k will be their number k = 0; for (j=0;jv1==i) && (vc[Edge[j]->v2]==1) && (kv2-1; if ((Edge[j]->v2==i) && (vc[Edge[j]->v1]==1) && (kv1-1; } if (k>1) { if (noCO2) noOxygens = ((Vertex[i-1]->type & almask)==ctype); // A group of vertices with single connection is // identified. Assign symmetry relief modifiers // to *equivalent* vertices in the group for (j=0;j=0) && (v[j]type & almask; if ((!noOxygens) || (vjtype!=otype)) { n = 1; // symmetry relief modifier for (m=j+1;m=0) && (v[m]type== (Vertex[v[m]]->type & almask)) { Vertex[v[m]]->type |= (n << 16); n++; v[m] = -1; } } } } } } FreeVectorMemory ( v ,0 ); FreeVectorMemory ( vc,1 ); } int CGraph::Build ( Boolean bondOrder ) { int i,j, rc; if (nVertices<=0) return 2; if (nGAllocv1>=1) && (Edge[i]->v1<=nVertices) && (Edge[i]->v2>=1) && (Edge[i]->v2<=nVertices)) { graph[Edge[i]->v1][Edge[i]->v2] = Edge[i]->type; graph[Edge[i]->v2][Edge[i]->v1] = Edge[i]->type; } else rc = 1; } else { for (i=0;iv1>=1) && (Edge[i]->v1<=nVertices) && (Edge[i]->v2>=1) && (Edge[i]->v2<=nVertices)) { graph[Edge[i]->v1][Edge[i]->v2] = 1; graph[Edge[i]->v2][Edge[i]->v1] = 1; } else rc = 1; } return rc; } const int ring_mask[] = { 0x00000000, 0x00000000, 0x00000000, 0x00000001, 0x00000002, 0x00000004, 0x00000008, 0x00000010, 0x00000020, 0x00000040, 0x00000080 }; void CGraph::IdentifyRings() { CGraphMatch GM; CGraph ring; ivector F1,F2; AtomName aname; realtype p1,p2; int i,j,n,nrings,nv; Build ( False ); for (i=0;itype_ext = 0; GM.SetFlag ( GMF_UniqueMatch ); for (n=3;n<=10;n++) { ring.Reset(); for (i=1;i<=n;i++) { sprintf ( aname,"C%i",i ); ring.AddVertex ( new CVertex("C",aname) ); } ring.MakeVertexIDs(); for (i=1;i<=n;i++) { j = i+1; if (j>n) j = 1; ring.AddEdge ( new CEdge(i,j,1) ); } ring.Build ( False ); GM.MatchGraphs ( this,&ring,n,False,EXTTYPE_Ignore ); nrings = GM.GetNofMatches(); for (i=0;itype_ext |= ring_mask[n]; } } } void CGraph::markConnected ( int vno, int cno ) { int i; Vertex[vno]->type_ext = cno; for (i=0;itype_ext)) markConnected ( i,cno ); } int CGraph::IdentifyConnectedComponents() { // Returns the number of connected components and sets // Vertex[]->type_ext equal to component number >=1. int nComponents,i; nComponents = 0; Build ( False ); for (i=0;itype_ext = 0; i = 0; while (itype_ext) i++; else break; if (i0) { printf ( " Vertices:\n"" ## " ); Vertex[0]->Print(1); printf ( "\n" ); for (i=0;iPrint(0); printf ( "\n" ); } } if (nEdges>0) { printf ( " Edges:\n"" ## " ); Edge[0]->Print(1); printf ( "\n" ); for (i=0;iPrint(0); printf ( "\n" ); } } } void CGraph::Print1() { int i,j; for (i=0;iid,Vertex[i]->type,Vertex[i]->name ); for (j=0;jv1==i+1) printf ( " %4i(%i)",Edge[j]->v2,Edge[j]->type ); else if (Edge[j]->v2==i+1) printf ( " %4i(%i)",Edge[j]->v1,Edge[j]->type ); printf ( "\n" ); } } void CGraph::Copy ( PCGraph G ) { int i; FreeMemory(); CreateCopy ( name,G->name ); nVertices = G->nVertices; nEdges = G->nEdges; nAllVertices = G->nAllVertices; nAllEdges = G->nAllEdges; if (nAllVertices>0) { nVAlloc = nAllVertices; Vertex = new PCVertex[nVAlloc]; for (i=0;iCopy ( G->Vertex[i] ); } } if (nAllEdges>0) { nEAlloc = nAllEdges; Edge = new PCEdge[nEAlloc]; for (i=0;iCopy ( G->Edge[i] ); } } } void CGraph::write ( RCFile f ) { int i; int Version=2; Boolean bondOrder=False; f.WriteInt ( &Version ); f.WriteBool ( &bondOrder ); f.CreateWrite ( name ); f.WriteInt ( &nVertices ); f.WriteInt ( &nEdges ); f.WriteInt ( &nAllVertices ); f.WriteInt ( &nAllEdges ); for (i=0;i1) { f.ReadInt ( &nAllVertices ); f.ReadInt ( &nAllEdges ); } else { nAllVertices = nVertices; nAllEdges = nEdges; } if (nAllVertices>0) { nVAlloc = nAllVertices; Vertex = new PCVertex[nVAlloc]; for (i=0;i0) { nEAlloc = nAllEdges; Edge = new PCEdge[nEAlloc]; for (i=0;imem_write ( S,l ); } else { k = 0; ::mem_write ( k,S,l ); } for (i=0;imem_write ( S,l ); } else { k = 0; ::mem_write ( k,S,l ); } } void CGraph::mem_read ( cpstr S, int & l ) { int i,k; byte Version; Boolean bondOrder; FreeMemory(); ::mem_read_byte ( Version,S,l ); ::mem_read ( bondOrder ,S,l ); ::mem_read ( name ,S,l ); ::mem_read ( nVertices ,S,l ); ::mem_read ( nEdges ,S,l ); ::mem_read ( nAllVertices,S,l ); ::mem_read ( nAllEdges ,S,l ); if (nAllVertices>0) { nVAlloc = nAllVertices; Vertex = new PCVertex[nVAlloc]; for (i=0;imem_read ( S,l ); } else Vertex[i] = NULL; } } if (nAllEdges>0) { nEAlloc = nAllEdges; Edge = new PCEdge[nEAlloc]; for (i=0;imem_read ( S,l ); } else { Edge[i] = NULL; } } } // Build ( bondOrder ); } MakeStreamFunctions(CGraph); // ========================== CMatch ============================ CMatch::CMatch() : CStream() { InitMatch(); } CMatch::CMatch ( RPCStream Object ) : CStream ( Object ) { InitMatch(); } CMatch::CMatch ( ivector FV1, ivector FV2, int nv, int n, int m ) { int i; if (FV1 && FV2) { n1 = n; n2 = m; nAlloc = n; GetVectorMemory ( F1,nAlloc,1 ); GetVectorMemory ( F2,nAlloc,1 ); mlength = nv; for (i=1;i<=mlength;i++) { F1[i] = FV1[i]; F2[i] = FV2[i]; } } else InitMatch(); } void CMatch::InitMatch() { mlength = 0; n1 = 0; n2 = 0; nAlloc = 0; F1 = NULL; F2 = NULL; } CMatch::~CMatch() { FreeVectorMemory ( F1,1 ); FreeVectorMemory ( F2,1 ); } void CMatch::SetMatch ( ivector FV1, ivector FV2, int nv, int n, int m ) { int i; if (FV1 && FV2) { if (nv>nAlloc) { FreeVectorMemory ( F1,1 ); FreeVectorMemory ( F2,1 ); nAlloc = n; GetVectorMemory ( F1,nAlloc,1 ); GetVectorMemory ( F2,nAlloc,1 ); } n1 = n; n2 = m; mlength = nv; for (i=1;i<=mlength;i++) { F1[i] = FV1[i]; F2[i] = FV2[i]; } } else { FreeVectorMemory ( F1,1 ); FreeVectorMemory ( F2,1 ); mlength = 0; n1 = 0; n2 = 0; } } Boolean CMatch::isMatch ( ivector FV1, ivector FV2, int nv ) { int i,j; Boolean B; if (FV1 && FV2 && (nv<=mlength)) { B = True; for (i=1;(i<=nv) && B;i++) { B = False; for (j=1;(j<=mlength) && (!B);j++) B = (FV1[i]==F1[j]) && (FV2[i]==F2[j]); } return B; } return False; } Boolean CMatch::isCombination ( ivector FV1, ivector FV2, int nv ) { int i,j; Boolean B; if (FV1 && FV2 && (nv==mlength)) { B = True; for (i=1;(i<=nv) && B;i++) { B = False; for (j=1;(j<=mlength) && (!B);j++) B = (FV1[i]==F1[j]); if (B) { B = False; for (j=1;(j<=mlength) && (!B);j++) B = (FV2[i]==F2[j]); } } return B; } return False; } void CMatch::GetMatch ( ivector & FV1, ivector & FV2, int & nv, realtype & p1, realtype & p2 ) { FV1 = F1; FV2 = F2; nv = mlength; p1 = mlength; if (p1>0.0) p1 /= n1; p2 = mlength; if (p2>0.0) p2 /= n2; } void CMatch::write ( RCFile f ) { int i; int Version=1; f.WriteInt ( &Version ); f.WriteInt ( &mlength ); f.WriteInt ( &n1 ); f.WriteInt ( &n2 ); for (i=1;i<=mlength;i++) { f.WriteInt ( &(F1[i]) ); f.WriteInt ( &(F2[i]) ); } } void CMatch::read ( RCFile f ) { int i,Version; FreeVectorMemory ( F1,1 ); FreeVectorMemory ( F2,1 ); f.ReadInt ( &Version ); f.ReadInt ( &mlength ); f.ReadInt ( &n1 ); f.ReadInt ( &n2 ); if (mlength>0) { nAlloc = n1; GetVectorMemory ( F1,nAlloc,1 ); GetVectorMemory ( F2,nAlloc,1 ); for (i=1;i<=mlength;i++) { f.ReadInt ( &(F1[i]) ); f.ReadInt ( &(F2[i]) ); } } } void CMatch::mem_write ( pstr S, int & l ) { int i; ::mem_write ( mlength,S,l ); ::mem_write ( n1 ,S,l ); ::mem_write ( n2 ,S,l ); for (i=1;i<=mlength;i++) { ::mem_write ( F1[i],S,l ); ::mem_write ( F2[i],S,l ); } } void CMatch::mem_read ( cpstr S, int & l ) { int i; FreeVectorMemory ( F1,1 ); FreeVectorMemory ( F2,1 ); ::mem_read ( mlength,S,l ); ::mem_read ( n1 ,S,l ); ::mem_read ( n2 ,S,l ); if (mlength>0) { nAlloc = n1; GetVectorMemory ( F1,nAlloc,1 ); GetVectorMemory ( F2,nAlloc,1 ); for (i=1;i<=mlength;i++) { ::mem_read ( F1[i],S,l ); ::mem_read ( F2[i],S,l ); } } } MakeStreamFunctions(CMatch); // ======================== CGraphMatch ========================== CGraphMatch::CGraphMatch() : CStream() { InitGraphMatch(); } CGraphMatch::CGraphMatch ( RPCStream Object ) : CStream ( Object ) { InitGraphMatch(); } CGraphMatch::~CGraphMatch() { FreeMemory(); } void CGraphMatch::InitGraphMatch() { G1 = NULL; G2 = NULL; n = 0; m = 0; P = NULL; nAlloc = 0; mAlloc = 0; nMatches = 0; maxNMatches = -1; // unlimited Match = NULL; nMAlloc = 0; flags = 0; swap = False; wasFullMatch = False; maxMatch = 0; timeLimit = 0; // no time limit Stop = False; stopOnMaxNMathches = False; F1 = NULL; F2 = NULL; iF1 = NULL; ix = NULL; #ifndef _UseRecursion jj = NULL; #endif } void CGraphMatch::SetFlag ( word flag ) { flags |= flag; } void CGraphMatch::RemoveFlag ( word flag ) { flags &= ~flag; } void CGraphMatch::SetMaxNofMatches ( int maxNofMatches, Boolean stopOnMaxN ) { maxNMatches = maxNofMatches; stopOnMaxNMathches = stopOnMaxN; } void CGraphMatch::SetTimeLimit ( int maxTimeToRun ) { timeLimit = maxTimeToRun; } void CGraphMatch::Reset() { FreeMemory(); } void CGraphMatch::FreeMemory() { int i; if (P) { FreeMatrixMemory ( P[1],nAlloc,1,0 ); FreeRecHeap (); P = P + 1; delete[] P; P = NULL; } FreeMatrixMemory ( iF1,nAlloc,1,1 ); FreeVectorMemory ( F1 ,1 ); FreeVectorMemory ( F2 ,1 ); FreeVectorMemory ( ix ,1 ); nAlloc = 0; mAlloc = 0; if (Match) { for (i=0;inVertices<=Gh2->nVertices) { G1 = Gh1; G2 = Gh2; swap = False; } else { G1 = Gh2; G2 = Gh1; swap = True; } n = G1->nVertices; m = G2->nVertices; V1 = G1->Vertex; V2 = G2->Vertex; c1 = G1->graph; c2 = G2->graph; nMatches = 0; if (n<=0) return; if ((n>nAlloc) || (m>mAlloc)) GetMemory(); else FreeRecHeap(); n1 = Initialize ( vertexType,vertexExt ); if (n1<=0) return; GetRecHeap(); maxMatch = IMax(1,IMin(n,minMatch)); Stop = False; startTime = time(NULL); // Use of Backtrack(..) and Ullman() is completely // equivalent. One of them should be commented. if (minMatch=minMatch) Backtrack1 ( 1,n1 ); } else if (n1>=n) { #ifdef _UseRecursion Backtrack ( 1 ); #else Ullman(); #endif } } int CGraphMatch::Initialize ( Boolean vertexType, int vertexExt ) { ivector jF1; int i,j,v1type,v1type_ext,v2type_ext,almask,iW,pl; wasFullMatch = False; jF1 = iF1[1]; for (i=1;i<=n;i++) jF1[i] = i; almask = ~ATOM_LEAVING; /* -- experiment for symmetry reliefs int v2type,v1type_sr,srmask; srmask = ~SYMREL_MASK; for (i=1;i<=n;i++) { if (vertexType) { ix[i] = 0; v1type = V1[i-1]->type & almask; v1type_sr = v1type & srmask; pl = 0; for (j=1;j<=m;j++) { v2type = V2[j-1]->type & almask; if ((v1type==v2type) || (v1type_sr==v2type) || (v1type==(v2type & srmask))) P[1][i][++pl] = j; } P[1][i][0] = pl; if (pl) ix[i] = i; } else { ix[i] = i; for (j=1;j<=m;j++) P[1][i][j] = j; P[1][i][0] = m; } F1[i] = 0; F2[i] = 0; } */ for (i=1;i<=n;i++) { ix[i] = 0; v1type = V1[i-1]->type & almask; v1type_ext = V1[i-1]->type_ext; pl = 0; for (j=1;j<=m;j++) if ((v1type==(V2[j-1]->type & almask)) || (!vertexType)) { if (vertexExt==EXTTYPE_Ignore) P[1][i][++pl] = j; else { v2type_ext = V2[j-1]->type_ext; if ((!v1type_ext) && (!v2type_ext)) P[1][i][++pl] = j; else switch (vertexExt) { default : case EXTTYPE_Ignore : P[1][i][++pl] = j; break; case EXTTYPE_Equal : if (v1type_ext==v2type_ext) P[1][i][++pl] = j; break; case EXTTYPE_AND : if (v1type_ext & v2type_ext) P[1][i][++pl] = j; break; case EXTTYPE_OR : if (v1type_ext | v2type_ext) P[1][i][++pl] = j; break; case EXTTYPE_XOR : if (v1type_ext ^ v2type_ext) P[1][i][++pl] = j; break; case EXTTYPE_NotEqual : if (v1type_ext!=v2type_ext) P[1][i][++pl] = j; break; case EXTTYPE_NotAND : if ((v1type_ext & v2type_ext) ==0) P[1][i][++pl] = j; break; case EXTTYPE_NotOR : if ((v1type_ext | v2type_ext) ==0) P[1][i][++pl] = j; } } } P[1][i][0] = pl; if (pl) ix[i] = i; F1[i] = 0; F2[i] = 0; } /* } else { for (i=1;i<=n;i++) { ix[i] = i; for (j=1;j<=m;j++) P[1][i][j] = j; P[1][i][0] = m; F1[i] = 0; F2[i] = 0; } } */ i = 1; j = n; while (i0) Stop = (difftime(time(NULL),startTime)>timeLimit); F1[i] = i; pli = P[i][i][0]; if (i>=n) { for (cntj=1;(cntj<=pli) && (!Stop);cntj++) { F2[n] = P[n][n][cntj]; CollectMatch ( n ); } } else { i1 = i+1; c1i = c1[i]; for (cntj=1;(cntj<=pli) && (!Stop);cntj++) { j = P[i][i][cntj]; F2[i] = j; // mapped F1[i]:F2[i], i.e. i:j // Forward checking c2j = c2[j]; pl2 = 1; for (k=i1;(k<=n) && (pl2>0);k++) { p1 = P[i][k]; p2 = P[i1][k]; c1ik = c1i[k]; pl1 = p1[0]; pl2 = 0; for (cntl=1;cntl<=pl1;cntl++) { l = p1[cntl]; if ((c1ik==c2j[l]) && // check that bonds are compatible (l!=j)) // and make sure jth vertex is excluded p2[++pl2] = l; } p2[0] = pl2; // new length of P-row } if (pl2>0) Backtrack ( i1 ); } } } #else void CGraphMatch::Ullman() { // A non-recursive translation of Ullman's Backtrack. // It might give some gain in performance, although tests // on SGI machine show that the gain is negligible, (if // there is any at all) if compiler's optimization is // switched on. int i,pl,i1,pli,cntj,j,pl1,pl2,k,cntl,l,l1,cik; ivector ci,cj; ivector p1,p2; if (Stop) return; if (timeLimit>0) Stop = (difftime(time(NULL),startTime)>timeLimit); i = 1; jj[1] = 1; pl = P[1][1][0]; do { F1[i] = i; pli = P[i][i][0]; if (i>=n) { for (cntj=jj[n];(cntj<=pli) && (!Stop);cntj++) { jj[n]++; F2[n] = P[n][n][cntj]; CollectMatch ( n ); } } else { i1 = i+1; ci = c1[i]; for (cntj=jj[i];(cntj<=pli) && (!Stop);cntj++) { jj[i]++; j = P[i][i][cntj]; F2[i] = j; // Forward checking cj = c2[j]; pl2 = 1; for (k=i1;(k<=n) && (pl2>0);k++) { p1 = P[i][k]; p2 = P[i1][k]; cik = ci[k]; pl1 = p1[0]; pl2 = 0; for (cntl=1;cntl<=pl1;cntl++) { l = p1[cntl]; if ((cik==cj[l]) && // check that bonds are compatible (l!=j)) // and make sure jth vertex is excluded p2[++pl2] = l; } p2[0] = pl2; // new length of P-row } if (pl2>0) { i++; jj[i] = 1; i++; // in order to compensate the following decrement break; } } } i--; } while ((!Stop) && ((jj[1]<=pl) || (i>1))); } #endif void CGraphMatch::Backtrack1 ( int i, int k0 ) { // Recursive version of CSIA algorithm for partial // (substructure-to-substructure) matching int i1,pl0,cntj,j,k,pl1,pl2,cntl,l,c1ik,ii,iW,k1; ivector jF1,c1i,c2j; ivector p0,p1,p2; if (Stop) return; if (timeLimit>0) Stop = (difftime(time(NULL),startTime)>timeLimit); jF1 = iF1[i]; if (i>=k0) { F1[i] = jF1[i]; p0 = P[i][jF1[i]]; pl0 = p0[0]; // collect matches of k0-th (the upmost) level if (pl0>0) { maxMatch = k0; for (cntj=1;cntj<=pl0;cntj++) { F2[k0] = p0[cntj]; CollectMatch ( k0 ); } } } else { i1 = i+1; pl0 = P[i][jF1[i]][0]; j = i; for (k=i1;k<=k0;k++) if (P[i][jF1[k]][0]i) { iW = jF1[i]; jF1[i] = jF1[j]; jF1[j] = iW; } F1[i] = jF1[i]; p0 = P[i][jF1[i]]; pl0 = p0[0]; c1i = c1[jF1[i]]; // 1. Find all matches that include jF1[i]th vertex of graph G1 for (cntj=1;(cntj<=pl0) && (!Stop);cntj++) { j = p0[cntj]; F2[i] = j; // mapped F1[i]:F2[i], i.e. iF1[i][i]:j // Forward checking c2j = c2[j]; k1 = k0; // k1 is the limit for match size for (k=i1;(k<=k0) && (k1>=maxMatch);k++) { ix[k] = 0; p1 = P[i] [jF1[k]]; p2 = P[i1][jF1[k]]; c1ik = c1i [jF1[k]]; pl1 = p1[0]; pl2 = 0; for (cntl=1;cntl<=pl1;cntl++) { l = p1[cntl]; if ((c1ik==c2j[l]) && // check that bonds are compatible (l!=j)) // and make sure jth vertex is excluded p2[++pl2] = l; } p2[0] = pl2; // new length of P-row if (pl2>0) { ix[k] = k; } else if (wasFullMatch) { k1 = maxMatch-1; // we are not interested in partial } else { // match anymore k1--; } } if (k1>=maxMatch) { // shift unmatching vertices to the end for (ii=1;ii<=n;ii++) iF1[i1][ii] = jF1[ii]; k = i1; l = k0; while (k=maxMatch) { CollectMatch ( i ); // collect match of ith level maxMatch = i; } } } // 2. Find all matches that do not include jF1[i]th vertex // of graph G1 if (k0>maxMatch) { // Shift jF1[i]th vertex to the end iW = jF1[i]; jF1[i] = jF1[k0]; jF1[k0] = iW; Backtrack1 ( i,k0-1 ); } } } void CGraphMatch::CollectMatch ( int nm ) { int i; Boolean B; PPCMatch M1; if (maxNMatches==0) return; // find out if this should be a new match if (nMatches>0) { // a match is already found; check with it if (nmmlength) return; if (nm>Match[0]->mlength) { nMatches = 0; } else if (flags & GMF_UniqueMatch) { // check if such a match was already found B = False; for (i=0;(iisMatch(F1,F2,nm); if (B) return; // repeating match -- just quit. } else if (flags & GMF_NoCombinations) { // check if such a match was already found B = False; for (i=0;(iisCombination(F1,F2,nm); if (B) return; // repeating match -- just quit. } } if (nMatches>=nMAlloc) { if ((nMAlloc0) nMAlloc = IMin(maxNMatches,nMAlloc+100); else nMAlloc += 100; M1 = new PCMatch[nMAlloc]; for (i=0;iSetMatch ( F1,F2,nm,n,m ); if (nm==n) wasFullMatch = True; if (nm>maxMatch) maxMatch = nm; nMatches++; if (stopOnMaxNMathches && (maxNMatches>0) && (nMatches>=maxNMatches)) Stop = True; } void CGraphMatch::PrintMatches() { int i,j,k; if (nMatches<=0) printf ( "\n\n *** NO MATCHES FOUND\n\n" ); else { if (flags & GMF_UniqueMatch) printf ( "\n\n *** FOUND Unique Matches\n\n" ); else printf ( "\n\n *** FOUND Matches\n\n" ); printf ( " ## Vertices\n" ); for (i=0;imlength;j++) { if (swap) printf ( " (%i,%i)",Match[i]->F2[j],Match[i]->F1[j] ); else printf ( " (%i,%i)",Match[i]->F1[j],Match[i]->F2[j] ); k += 8; if (k>70) { printf ( "\n" ); k = 8; } } printf ( "\n" ); } } printf ( "\n **************************\n" ); } void CGraphMatch::GetMatch ( int MatchNo, ivector & FV1, ivector & FV2, int & nv, realtype & p1, realtype & p2 ) { // do not allocate or dispose FV1 and FV2 in application! // FV1/p1 will always correspond to Gh1, and FV2/p2 - // to Gh2 as specified in MatchGraphs(..) if ((MatchNo<0) || (MatchNo>=nMatches)) { FV1 = NULL; FV2 = NULL; nv = 0; p1 = 0.0; p2 = 0.0; } else if (swap) Match[MatchNo]->GetMatch ( FV2,FV1,nv,p2,p1 ); else Match[MatchNo]->GetMatch ( FV1,FV2,nv,p1,p2 ); } void CGraphMatch::write ( RCFile f ) { int i; int Version=1; f.WriteInt ( &Version ); f.WriteInt ( &nMatches ); f.WriteWord ( &flags ); f.WriteBool ( &swap ); for (i=0;iwrite ( f ); } void CGraphMatch::read ( RCFile f ) { int i,Version; FreeMemory (); f.ReadInt ( &Version ); f.ReadInt ( &nMatches ); f.ReadWord ( &flags ); f.ReadBool ( &swap ); if (nMatches>0) { nMAlloc = nMatches; Match = new PCMatch[nMatches]; for (i=0;iread ( f ); } } } void CGraphMatch::mem_write ( pstr S, int & l ) { int i; ::mem_write ( nMatches,S,l ); ::mem_write ( flags ,S,l ); ::mem_write ( swap ,S,l ); for (i=0;imem_write ( S,l ); } void CGraphMatch::mem_read ( cpstr S, int & l ) { int i; FreeMemory (); ::mem_read ( nMatches,S,l ); ::mem_read ( flags ,S,l ); ::mem_read ( swap ,S,l ); if (nMatches>0) { nMAlloc = nMatches; Match = new PCMatch[nMatches]; for (i=0;imem_read ( S,l ); } } } MakeStreamFunctions(CGraphMatch); // ============================================================= /* static char Mol1[][3] = { "C", "C", "C", "C", "C", "C" }; static int Bond1[] = { 1, 2, 1, 6, 2, 3, 3, 4, 4, 5, 5, 6 }; static char Mol2[][3] = { "C", "C", "C", "C", "C", "C", "C", "C", "C", "C", "C", "C" }; static int Bond2[] = { 1, 2, 1, 6, 2, 3, 3, 4, 4, 5, 5, 6, 1, 7, 2, 8, 3, 9, 4, 10, 5, 11, 6, 12 }; static char Mol1[][3] = { "C", "C", "N", "C" }; static int Bond1[] = { 1, 2, 2, 3, 3, 4 }; static char Mol2[][3] = { "C", "C", "N", "C" }; static int Bond2[] = { 1, 2, 2, 3, 2, 4, 3, 4 }; void TestGraphMatch() { int i,k1,k2, nv1,nb1, nv2,nb2; PCVertex V; PCEdge G; CGraph G1,G2; CGraphMatch U; G1.Reset (); G1.SetName ( "#1" ); nv1 = sizeof(Mol1)/3; for (i=0;iSetVertex ( Mol1[i] ); G1.AddVertex ( V ); } nb1 = sizeof(Bond1)/(2*sizeof(int)); k1 = 0; k2 = 1; for (i=0;iSetEdge ( Bond1[k1],Bond1[k2],1 ); G1.AddEdge ( G ); k1 += 2; k2 += 2; } G2.Reset (); G2.SetName ( "#2" ); nv2 = sizeof(Mol2)/3; for (i=0;iSetVertex ( Mol2[i] ); G2.AddVertex ( V ); } nb2 = sizeof(Bond2)/(2*sizeof(int)); k1 = 0; k2 = 1; for (i=0;iSetEdge ( Bond2[k1],Bond2[k2],1 ); G2.AddEdge ( G ); k1 += 2; k2 += 2; } G1.Build(); G2.Build(); U.MatchGraphs ( &G1,&G2,nv1 ); U.PrintMatches(); } */ mmdb-1.25.5/mmdb/mmdb_atom.cpp0000775000175000017500000026477712137762507013074 00000000000000// $Id: mmdb_atom.cpp,v 1.31 2012/01/26 17:52:20 ekr Exp $ // ================================================================= // // CCP4 Coordinate Library: support of coordinate-related // functionality in protein crystallography applications. // // Copyright (C) Eugene Krissinel 2000-2008. // // This library is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // // ================================================================= // // 23.04.13 <-- Date of Last Modification. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ----------------------------------------------------------------- // // **** Module : MMDB_Atom // ~~~~~~~~~ // **** Project : MacroMolecular Data Base (MMDB) // ~~~~~~~~~ // **** Classes : CAtom ( atom class ) // ~~~~~~~~~ CResidue ( residue class ) // // Copyright (C) E. Krissinel 2000-2013 // // ================================================================= // #ifndef __STRING_H #include #endif #ifndef __STDLIB_H #include #endif #ifndef __MATH_H #include #endif #ifndef __MMDB_Chain__ #include "mmdb_chain.h" #endif #ifndef __MMDB_Model__ #include "mmdb_model.h" #endif #ifndef __MMDB_File__ #include "mmdb_file.h" #endif #ifndef __MMDB_Tables__ #include "mmdb_tables.h" #endif #ifndef __MMDB_CIFDefs__ #include "mmdb_cifdefs.h" #endif #ifndef IOTBX_PDB_HYBRID_36_C_H #include "hybrid_36.h" #endif // ================================================================ #define ASET_ShortBinary 0x10000000 #define ASET_ShortTer 0x20000000 #define ASET_ShortHet 0x40000000 Boolean ignoreSegID = False; Boolean ignoreElement = False; Boolean ignoreCharge = False; Boolean ignoreNonCoorPDBErrors = False; Boolean ignoreUnmatch = False; // ========================== CAtom ============================= CAtom::CAtom() : CUDData() { InitAtom(); } CAtom::CAtom ( PCResidue res ) : CUDData() { InitAtom(); if (res) res->AddAtom ( this ); } CAtom::CAtom ( RPCStream Object ) : CUDData(Object) { InitAtom(); } CAtom::~CAtom() { int nA; PPCAtom A; FreeMemory(); if (residue) { A = NULL; nA = 0; if (residue->chain) { if (residue->chain->model) { A = residue->chain->model->GetAllAtoms(); nA = residue->chain->model->GetNumberOfAllAtoms(); } } residue->_ExcludeAtom ( index ); if ((0index; else AtomBondI[i].index = -1; AtomBondI[i].order = Bond[i].order; } } } void CAtom::GetBonds ( PSAtomBondI AtomBondI, int & nAtomBonds, int maxlength ) { // This GetBonds(..) does not dispose or allocate AtomBond. // It is assumed that length of AtomBond is sufficient to // accomodate all bonded atoms. int i; nAtomBonds = IMin(maxlength,nBonds & 0x000000FF); for (i=0;iindex; else AtomBondI[i].index = -1; AtomBondI[i].order = Bond[i].order; } } int CAtom::AddBond ( PCAtom bond_atom, int bond_order, int nAdd_bonds ) { PSAtomBond B1; int i,k,nb,nballoc; nb = nBonds & 0x000000FF; k = -1; for (i=0;(i=0) return -k; nballoc = (nBonds >> 8) & 0x000000FF; if (nBonds>=nballoc) { nballoc += nAdd_bonds; B1 = new SAtomBond[nballoc]; for (i=0;i99999) { hy36encode ( 5,serNum,N ); strcpy_n ( &(S[6]),N,5 ); } else if (serNum>0) PutInteger ( &(S[6]),serNum,5 ); else if (index<=99999) PutInteger ( &(S[6]),index,5 ); else { hy36encode ( 5,index,N ); strcpy_n ( &(S[6]),N,5 ); } if (!Ter) { if (altLoc[0]) S[16] = altLoc[0]; strcpy_n ( &(S[12]),name ,4 ); strcpy_n ( &(S[72]),segID ,4 ); strcpy_nr ( &(S[76]),element,2 ); if (WhatIsSet & ASET_Charge) { if (charge>0) sprintf ( N,"%1i+",mround(charge) ); else if (charge<0) sprintf ( N,"%1i-",mround(-charge) ); else strcpy ( N," " ); strcpy_n ( &(S[78]),N,2 ); } else strcpy_n ( &(S[78])," ",2 ); } strcpy_nr ( &(S[17]),residue->name,3 ); strcpy_nr ( &(S[20]),residue->chain->chainID,2 ); if (residue->seqNum>MinInt4) { if ((-999<=residue->seqNum) && (residue->seqNum<=9999)) PutIntIns ( &(S[22]),residue->seqNum,4,residue->insCode ); else { hy36encode ( 4,residue->seqNum,N ); strcpy_n ( &(S[22]),N,4 ); } } } void CAtom::PDBASCIIDump ( RCFile f ) { // makes the ASCII PDB ATOM, HETATM, SIGATOM, ANISOU // SIGUIJ and TER lines from the class' data char S[100]; if (Ter) { if (WhatIsSet & ASET_Coordinates) { StandardPDBOut ( pstr("TER"),S ); f.WriteLine ( S ); } } else { if (WhatIsSet & ASET_Coordinates) { if (Het) StandardPDBOut ( pstr("HETATM"),S ); else StandardPDBOut ( pstr("ATOM") ,S ); PutRealF ( &(S[30]),x,8,3 ); PutRealF ( &(S[38]),y,8,3 ); PutRealF ( &(S[46]),z,8,3 ); if (WhatIsSet & ASET_Occupancy) PutRealF ( &(S[54]),occupancy ,6,2 ); if (WhatIsSet & ASET_tempFactor) PutRealF ( &(S[60]),tempFactor,6,2 ); f.WriteLine ( S ); } if (WhatIsSet & ASET_CoordSigma) { StandardPDBOut ( pstr("SIGATM"),S ); PutRealF ( &(S[30]),sigX,8,3 ); PutRealF ( &(S[38]),sigY,8,3 ); PutRealF ( &(S[46]),sigZ,8,3 ); if ((WhatIsSet & ASET_OccSigma) && (WhatIsSet & ASET_Occupancy)) PutRealF ( &(S[54]),sigOcc,6,2 ); if ((WhatIsSet & ASET_tFacSigma) && (WhatIsSet & ASET_tempFactor)) PutRealF ( &(S[60]),sigTemp,6,2 ); f.WriteLine ( S ); } if (WhatIsSet & ASET_Anis_tFac) { StandardPDBOut ( pstr("ANISOU"),S ); PutInteger ( &(S[28]),mround(u11*1.0e4),7 ); PutInteger ( &(S[35]),mround(u22*1.0e4),7 ); PutInteger ( &(S[42]),mround(u33*1.0e4),7 ); PutInteger ( &(S[49]),mround(u12*1.0e4),7 ); PutInteger ( &(S[56]),mround(u13*1.0e4),7 ); PutInteger ( &(S[63]),mround(u23*1.0e4),7 ); f.WriteLine ( S ); if (WhatIsSet & ASET_Anis_tFSigma) { StandardPDBOut ( pstr("SIGUIJ"),S ); PutInteger ( &(S[28]),mround(su11*1.0e4),7 ); PutInteger ( &(S[35]),mround(su22*1.0e4),7 ); PutInteger ( &(S[42]),mround(su33*1.0e4),7 ); PutInteger ( &(S[49]),mround(su12*1.0e4),7 ); PutInteger ( &(S[56]),mround(su13*1.0e4),7 ); PutInteger ( &(S[63]),mround(su23*1.0e4),7 ); f.WriteLine ( S ); } } } } void CAtom::MakeCIF ( PCMMCIFData CIF ) { PCMMCIFLoop Loop; AtomName AtName; Element el; char N[10]; int i,j,RC; PCChain chain = NULL; PCModel model = NULL; //Boolean singleModel = True; if (residue) chain = residue->chain; if (chain) model = PCModel(chain->model); // if (model) { // if (model->manager) // singleModel = PCMMDBFile(model->manager)->nModels<=1; // } /* loop_ *0 _atom_site.group_PDB *1 _atom_site.id *2 _atom_site.type_symbol <- chem elem -3 _atom_site.label_atom_id <- atom name *4 _atom_site.label_alt_id <- alt code =5 _atom_site.label_comp_id <- res name ??? =6 _atom_site.label_asym_id <- chain id ??? =7 _atom_site.label_entity_id < ??? =8 _atom_site.label_seq_id <- poly seq id +9 _atom_site.pdbx_PDB_ins_code <- ins code -10 _atom_site.segment_id <- segment id *11 _atom_site.Cartn_x *12 _atom_site.Cartn_y *13 _atom_site.Cartn_z *14 _atom_site.occupancy *15 _atom_site.B_iso_or_equiv *16 _atom_site.Cartn_x_esd *17 _atom_site.Cartn_y_esd *18 _atom_site.Cartn_z_esd *19 _atom_site.occupancy_esd *20 _atom_site.B_iso_or_equiv_esd *21 _atom_site.pdbx_formal_charge +22 _atom_site.auth_seq_id <- seq id we want +23 _atom_site.auth_comp_id <- res name we want +24 _atom_site.auth_asym_id <- ch id we want ? *25 _atom_site.auth_atom_id <- atom name we want ? +26 _atom_site.pdbx_PDB_model_num <- model no '+' is read in CMMDBFile::CheckAtomPlace() '=' new in residue '-' new in atom */ RC = CIF->AddLoop ( CIFCAT_ATOM_SITE,Loop ); if (RC!=CIFRC_Ok) { // the category was (re)created, provide tags Loop->AddLoopTag ( CIFTAG_GROUP_PDB ); // ATOM, TER etc. Loop->AddLoopTag ( CIFTAG_ID ); // serial number Loop->AddLoopTag ( CIFTAG_TYPE_SYMBOL ); // element symbol Loop->AddLoopTag ( CIFTAG_LABEL_ATOM_ID ); // atom name Loop->AddLoopTag ( CIFTAG_LABEL_ALT_ID ); // alt location Loop->AddLoopTag ( CIFTAG_LABEL_COMP_ID ); // residue name Loop->AddLoopTag ( CIFTAG_LABEL_ASYM_ID ); // chain ID Loop->AddLoopTag ( CIFTAG_LABEL_ENTITY_ID ); // entity ID Loop->AddLoopTag ( CIFTAG_LABEL_SEQ_ID ); // res seq number Loop->AddLoopTag ( CIFTAG_PDBX_PDB_INS_CODE ); // insertion code Loop->AddLoopTag ( CIFTAG_SEGMENT_ID ); // segment ID Loop->AddLoopTag ( CIFTAG_CARTN_X ); // x-coordinate Loop->AddLoopTag ( CIFTAG_CARTN_Y ); // y-coordinate Loop->AddLoopTag ( CIFTAG_CARTN_Z ); // z-coordinate Loop->AddLoopTag ( CIFTAG_OCCUPANCY ); // occupancy Loop->AddLoopTag ( CIFTAG_B_ISO_OR_EQUIV ); // temp factor Loop->AddLoopTag ( CIFTAG_CARTN_X_ESD ); // x-sigma Loop->AddLoopTag ( CIFTAG_CARTN_Y_ESD ); // y-sigma Loop->AddLoopTag ( CIFTAG_CARTN_Z_ESD ); // z-sigma Loop->AddLoopTag ( CIFTAG_OCCUPANCY_ESD ); // occupancy-sigma Loop->AddLoopTag ( CIFTAG_B_ISO_OR_EQUIV_ESD ); // t-factor-sigma Loop->AddLoopTag ( CIFTAG_PDBX_FORMAL_CHARGE ); // charge on atom Loop->AddLoopTag ( CIFTAG_AUTH_SEQ_ID ); // res seq number Loop->AddLoopTag ( CIFTAG_AUTH_COMP_ID ); // residue name Loop->AddLoopTag ( CIFTAG_AUTH_ASYM_ID ); // chain id Loop->AddLoopTag ( CIFTAG_AUTH_ATOM_ID ); // atom name Loop->AddLoopTag ( CIFTAG_PDBX_PDB_MODEL_NUM ); // model number } if (Ter) { // ter record if (!(WhatIsSet & ASET_Coordinates)) return; // (0) Loop->AddString ( pstr("TER") ); // (1) if (serNum>0) Loop->AddInteger ( serNum ); else Loop->AddInteger ( index ); // (2,3,4) Loop->AddNoData ( CIF_NODATA_QUESTION ); // no element symbol Loop->AddNoData ( CIF_NODATA_QUESTION ); // no atom name Loop->AddNoData ( CIF_NODATA_QUESTION ); // no alt code if (residue) { // (5) Loop->AddString ( residue->label_comp_id ); // (6) Loop->AddString ( residue->label_asym_id ); // (7) if (residue->label_entity_id>0) Loop->AddInteger ( residue->label_entity_id ); else Loop->AddNoData ( CIF_NODATA_DOT ); // (8) if (residue->label_seq_id>MinInt4) Loop->AddInteger ( residue->label_seq_id ); else Loop->AddNoData ( CIF_NODATA_DOT ); // (9) Loop->AddString ( residue->insCode,True ); } else { // (5,6,7,8,9) Loop->AddString ( NULL ); Loop->AddString ( NULL ); Loop->AddNoData ( CIF_NODATA_DOT ); Loop->AddNoData ( CIF_NODATA_DOT ); Loop->AddNoData ( CIF_NODATA_DOT ); } // (10-21) for (i=10;i<=21;i++) Loop->AddNoData ( CIF_NODATA_QUESTION ); // (22,23) if (residue) { if (residue->seqNum>MinInt4) Loop->AddInteger ( residue->seqNum ); else Loop->AddNoData ( CIF_NODATA_DOT ); Loop->AddString ( residue->name ); } else { Loop->AddNoData ( CIF_NODATA_DOT ); Loop->AddString ( NULL ); } // (24) if (chain) Loop->AddString ( chain->chainID,True ); else Loop->AddString ( NULL ); // (25) Loop->AddNoData ( CIF_NODATA_QUESTION ); // no atom name } else if (WhatIsSet & (ASET_Coordinates | ASET_CoordSigma)) { // normal atom record if (!WhatIsSet) return; // (0) if (Het) Loop->AddString ( pstr("HETATM") ); else Loop->AddString ( pstr("ATOM") ); // (1) if (serNum>0) Loop->AddInteger ( serNum ); else Loop->AddInteger ( index ); if (WhatIsSet & ASET_Coordinates) { // (2) strcpy_css ( el,element ); Loop->AddString ( el,True ); // (3) Loop->AddString ( label_atom_id ); // assigned atom name // (4) Loop->AddString ( altLoc,True ); // alt code if (residue) { // (5) Loop->AddString ( residue->label_comp_id ); // (6) Loop->AddString ( residue->label_asym_id ); // (7) if (residue->label_entity_id>0) Loop->AddInteger ( residue->label_entity_id ); else Loop->AddNoData ( CIF_NODATA_DOT ); // (8) if (residue->label_seq_id>MinInt4) Loop->AddInteger ( residue->label_seq_id ); else Loop->AddNoData ( CIF_NODATA_DOT ); // (9) Loop->AddString ( residue->insCode,True ); } else { // (5,6,7,8,9) Loop->AddString ( NULL ); Loop->AddString ( NULL ); Loop->AddNoData ( CIF_NODATA_DOT ); Loop->AddNoData ( CIF_NODATA_DOT ); Loop->AddNoData ( CIF_NODATA_DOT ); } // (10) Loop->AddString ( segID ,True ); // (11,12,13) Loop->AddReal ( x ); Loop->AddReal ( y ); Loop->AddReal ( z ); // (14) if (WhatIsSet & ASET_Occupancy) Loop->AddReal ( occupancy ); else Loop->AddNoData ( CIF_NODATA_QUESTION ); // (15) if (WhatIsSet & ASET_tempFactor) Loop->AddReal ( tempFactor ); else Loop->AddNoData ( CIF_NODATA_QUESTION ); // (16,17,18) if (WhatIsSet & ASET_CoordSigma) { Loop->AddReal ( sigX ); Loop->AddReal ( sigY ); Loop->AddReal ( sigZ ); } else { Loop->AddNoData ( CIF_NODATA_QUESTION ); Loop->AddNoData ( CIF_NODATA_QUESTION ); Loop->AddNoData ( CIF_NODATA_QUESTION ); } // (19) if ((WhatIsSet & ASET_OccSigma) && (WhatIsSet & ASET_Occupancy)) Loop->AddReal ( sigOcc ); else Loop->AddNoData ( CIF_NODATA_QUESTION ); // (20) if ((WhatIsSet & ASET_tFacSigma) && (WhatIsSet & ASET_tempFactor)) Loop->AddReal ( sigTemp ); else Loop->AddNoData ( CIF_NODATA_QUESTION ); } else for (i=0;i<18;i++) Loop->AddNoData ( CIF_NODATA_QUESTION ); // (21) if (WhatIsSet & ASET_Charge) { sprintf ( N,"%+2i",mround(charge) ); Loop->AddString ( N,True ); } else Loop->AddNoData ( CIF_NODATA_QUESTION ); if (residue) { // (22) if (residue->seqNum>MinInt4) Loop->AddInteger ( residue->seqNum ); else Loop->AddNoData ( CIF_NODATA_DOT ); // (23) Loop->AddString ( residue->name ); } else { Loop->AddNoData ( CIF_NODATA_DOT ); Loop->AddNoData ( CIF_NODATA_DOT ); } // (24) if (chain) Loop->AddString ( chain->chainID,True ); else Loop->AddNoData ( CIF_NODATA_DOT ); // (25) strcpy_css ( AtName,name ); Loop->AddString ( AtName ); // atom name } // (26) if (!model) Loop->AddNoData ( CIF_NODATA_QUESTION ); else if (model->serNum>0) Loop->AddInteger ( model->serNum ); else Loop->AddNoData ( CIF_NODATA_QUESTION ); if (WhatIsSet & ASET_Anis_tFac) { RC = CIF->AddLoop ( CIFCAT_ATOM_SITE_ANISOTROP,Loop ); if (RC!=CIFRC_Ok) { // the category was (re)created, provide tags Loop->AddLoopTag ( CIFTAG_ID ); // serial number Loop->AddLoopTag ( CIFTAG_U11 ); // component u11 Loop->AddLoopTag ( CIFTAG_U22 ); // component u22 Loop->AddLoopTag ( CIFTAG_U33 ); // component u33 Loop->AddLoopTag ( CIFTAG_U12 ); // component u12 Loop->AddLoopTag ( CIFTAG_U13 ); // component u13 Loop->AddLoopTag ( CIFTAG_U23 ); // component u23 Loop->AddLoopTag ( CIFTAG_U11_ESD ); // component u11 sigma Loop->AddLoopTag ( CIFTAG_U22_ESD ); // component u22 sigma Loop->AddLoopTag ( CIFTAG_U33_ESD ); // component u33 sigma Loop->AddLoopTag ( CIFTAG_U12_ESD ); // component u12 sigma Loop->AddLoopTag ( CIFTAG_U13_ESD ); // component u13 sigma Loop->AddLoopTag ( CIFTAG_U23_ESD ); // component u23 sigma for (i=1;iAddInteger ( i ); for (j=0;j<12;j++) Loop->AddString ( NULL ); } } if (serNum>0) Loop->AddInteger ( serNum ); else Loop->AddInteger ( index ); Loop->AddReal ( u11 ); Loop->AddReal ( u22 ); Loop->AddReal ( u33 ); Loop->AddReal ( u12 ); Loop->AddReal ( u13 ); Loop->AddReal ( u23 ); if (WhatIsSet & ASET_Anis_tFSigma) { Loop->AddReal ( su11 ); Loop->AddReal ( su22 ); Loop->AddReal ( su33 ); Loop->AddReal ( su12 ); Loop->AddReal ( su13 ); Loop->AddReal ( su23 ); } } } int CAtom::ConvertPDBATOM ( int ix, cpstr S ) { // Gets data from the PDB ASCII ATOM record. // This function DOES NOT check the "ATOM" keyword and // does not decode the chain and residue parameters! These // must be treated by calling process, see // Chain::ConvertPDBASCII(). index = ix; if (WhatIsSet & ASET_Coordinates) return Error_ATOM_AlreadySet; if (!(GetReal(x,&(S[30]),8) && GetReal(y,&(S[38]),8) && GetReal(z,&(S[46]),8))) return Error_ATOM_Unrecognized; WhatIsSet |= ASET_Coordinates; Het = False; Ter = False; if (GetReal(occupancy ,&(S[54]),6)) WhatIsSet |= ASET_Occupancy; if (GetReal(tempFactor,&(S[60]),6)) WhatIsSet |= ASET_tempFactor; if (WhatIsSet & (ASET_CoordSigma | ASET_Anis_tFac | ASET_Anis_tFSigma)) // something was already submitted. check complience return CheckData ( S ); else // first data submission. just take the data GetData ( S ); return 0; } void CAtom::SetAtomName ( int ix, int sN, const AtomName aName, const AltLoc aLoc, const SegID sID, const Element eName ) { index = ix; serNum = sN; strcpy ( name ,aName ); strcpy ( label_atom_id,aName ); strcpy_css ( altLoc ,pstr(aLoc) ); strcpy_css ( segID ,pstr(sID) ); if (!eName[0]) element[0] = char(0); else if (!eName[1]) { element[0] = ' '; strcpy ( &(element[1]),eName ); } else strcpy ( element,eName ); WhatIsSet = 0; } int CAtom::ConvertPDBSIGATM ( int ix, cpstr S ) { // Gets data from the PDB ASCII SIGATM record. // This function DOES NOT check the "SIGATM" keyword and // does not decode the chain and residue parameters! These // must be treated by the calling process, see // Chain::ConvertPDBASCII(). index = ix; if (WhatIsSet & ASET_CoordSigma) return Error_ATOM_AlreadySet; if (!(GetReal(sigX,&(S[30]),8) && GetReal(sigY,&(S[38]),8) && GetReal(sigZ,&(S[46]),8))) return Error_ATOM_Unrecognized; WhatIsSet |= ASET_CoordSigma; if (GetReal(sigOcc ,&(S[54]),6)) WhatIsSet |= ASET_OccSigma; if (GetReal(sigTemp,&(S[60]),6)) WhatIsSet |= ASET_tFacSigma; if (WhatIsSet & (ASET_Coordinates | ASET_Anis_tFac | ASET_Anis_tFSigma)) // something was already submitted. check complience return CheckData ( S ); else // first data submission. just take the data GetData ( S ); return 0; } int CAtom::ConvertPDBANISOU ( int ix, cpstr S ) { // Gets data from the PDB ASCII ANISOU record. // This function DOES NOT check the "ANISOU" keyword and // does not decode chain and residue parameters! These must // be treated by the calling process, see // Chain::ConvertPDBASCII(). index = ix; if (WhatIsSet & ASET_Anis_tFac) return Error_ATOM_AlreadySet; if (!(GetReal(u11,&(S[28]),7) && GetReal(u22,&(S[35]),7) && GetReal(u33,&(S[42]),7) && GetReal(u12,&(S[49]),7) && GetReal(u13,&(S[56]),7) && GetReal(u23,&(S[63]),7))) return Error_ATOM_Unrecognized; u11 /= 1.0e4; u22 /= 1.0e4; u33 /= 1.0e4; u12 /= 1.0e4; u13 /= 1.0e4; u23 /= 1.0e4; WhatIsSet |= ASET_Anis_tFac; if (WhatIsSet & (ASET_Coordinates | ASET_CoordSigma | ASET_Anis_tFSigma)) // something was already submitted. check complience return CheckData ( S ); else // first data submission. just take the data GetData ( S ); return 0; } int CAtom::ConvertPDBSIGUIJ ( int ix, cpstr S ) { // Gets data from the PDB ASCII SIGUIJ record. // This function DOES NOT check the "SIGUIJ" keyword and // does not decode the chain and residue parameters! These // must be treated by the calling process, see // Chain::ConvertPDBASCII(). index = ix; if (WhatIsSet & ASET_Anis_tFSigma) return Error_ATOM_AlreadySet; if (!(GetReal(su11,&(S[28]),7) && GetReal(su22,&(S[35]),7) && GetReal(su33,&(S[42]),7) && GetReal(su12,&(S[49]),7) && GetReal(su13,&(S[56]),7) && GetReal(su23,&(S[63]),7))) return Error_ATOM_Unrecognized; su11 /= 1.0e4; su22 /= 1.0e4; su33 /= 1.0e4; su12 /= 1.0e4; su13 /= 1.0e4; su23 /= 1.0e4; WhatIsSet |= ASET_Anis_tFSigma; if (WhatIsSet & (ASET_Coordinates | ASET_CoordSigma | ASET_Anis_tFac)) // something was already submitted. check complience return CheckData ( S ); else // first data submission. just take the data GetData ( S ); return 0; } int CAtom::ConvertPDBTER ( int ix, cpstr S ) { // Gets data from the PDB ASCII TER record. // This function DOES NOT check the "TER" keyword and // does not decode the chain and residue parameters! These // must be treated by the calling process, see // Chain::ConvertPDBASCII(). index = ix; if (((S[6]>='0') && (S[6]<='9')) || (S[6]==' ')) { // Although against strict PDB format, 'TER' is // actually allowed not to have a serial number. // This negative value implies that the number is // not set. if (!(GetInteger(serNum,&(S[6]),5))) serNum = -1; } else hy36decode ( 5,&(S[6]),5,&serNum ); // if (!(GetInteger(serNum,&(S[6]),5))) serNum = -1; if (WhatIsSet & ASET_Coordinates) return Error_ATOM_AlreadySet; WhatIsSet |= ASET_Coordinates; Het = False; Ter = True; name[0] = char(0); label_atom_id[0] = char(0); element[0] = char(0); return 0; } int CAtom::GetModelNum() { if (residue) { if (residue->chain) if (residue->chain->model) return residue->chain->model->GetSerNum(); } return 0; } pstr CAtom::GetChainID() { if (residue) { if (residue->chain) return residue->chain->chainID; } return pstr(""); } pstr CAtom::GetLabelAsymID() { if (residue) return residue->label_asym_id; else return pstr(""); } pstr CAtom::GetResName() { if (residue) return residue->name; else return pstr(""); } pstr CAtom::GetLabelCompID() { if (residue) return residue->label_comp_id; else return pstr(""); } int CAtom::GetAASimilarity ( const ResName resName ) { if (residue) return ::GetAASimilarity ( pstr(residue->name), pstr(resName) ); else return -3; } int CAtom::GetAASimilarity ( PCAtom A ) { if (residue) { if (A->residue) return ::GetAASimilarity ( pstr(residue->name), pstr(A->residue->name) ); else return -4; } else return -3; } realtype CAtom::GetAAHydropathy() { if (residue) return ::GetAAHydropathy ( pstr(residue->name) ); else return MaxReal; } realtype CAtom::GetOccupancy() { if (WhatIsSet & ASET_Occupancy) return occupancy; else return 0.0; } int CAtom::GetSeqNum() { if (residue) return residue->seqNum; else return ATOM_NoSeqNum; } int CAtom::GetLabelSeqID() { if (residue) return residue->label_seq_id; else return ATOM_NoSeqNum; } int CAtom::GetLabelEntityID() { if (residue) return residue->label_entity_id; else return -1; } pstr CAtom::GetInsCode() { if (residue) return residue->insCode; else return pstr(""); } int CAtom::GetSSEType() { // works only after SSE calculations if (residue) return residue->SSE; else return SSE_None; } pstr CAtom::GetAtomCharge ( pstr chrg ) { if (WhatIsSet & ASET_Charge) sprintf ( chrg,"%+2i",mround(charge) ); else strcpy ( chrg," " ); return chrg; } PCResidue CAtom::GetResidue() { return residue; } PCChain CAtom::GetChain() { if (residue) return residue->chain; else return NULL; } PCModel CAtom::GetModel() { if (residue) { if (residue->chain) return (PCModel)residue->chain->model; } return NULL; } int CAtom::GetResidueNo() { if (residue) { if (residue->chain) return residue->chain->GetResidueNo ( residue->seqNum,residue->insCode ); else return -2; } else return -1; } void * CAtom::GetCoordHierarchy() { if (residue) return residue->GetCoordHierarchy(); return NULL; } void CAtom::GetStat ( realtype v, realtype & v_min, realtype & v_max, realtype & v_m, realtype & v_m2 ) { if (vv_max) v_max = v; v_m += v; v_m2 += v*v; } void CAtom::GetChainCalphas ( PPCAtom & Calphas, int & nCalphas, cpstr altLoc ) { // GetChainCalphas(...) is a specialized function for quick // access to C-alphas of chain which includes given atom. // This function works faster than an equivalent implementation // through MMDB's selection procedures. // Parameters: // Calphas - array to accept pointers on C-alpha atoms // If Calphas!=NULL, then the function will // delete and re-allocate it. When the array // is no longer needed, the application MUST // delete it: delete[] Calphas; Deleting // Calphas does not delete atoms from MMDB. // nCalphas - integer to accept number of C-alpha atoms // and the length of Calphas array. // altLoc - alternative location indicator. By default // (""), maximum-occupancy locations are taken. PCChain chain; PPCResidue res; PPCAtom atom; int nResidues, nAtoms, i,j,k; if (Calphas) { delete[] Calphas; Calphas = NULL; } nCalphas = 0; if (residue) chain = residue->chain; else chain = NULL; if (chain) { chain->GetResidueTable ( res,nResidues ); if (nResidues>0) { Calphas = new PCAtom[nResidues]; if ((!altLoc[0]) || (altLoc[0]==' ')) { // main conformation for (i=0;inAtoms; atom = res[i]->atom; for (j=0;jname," CA ")) { Calphas[nCalphas++] = atom[j]; break; } } } else { // specific conformation for (i=0;inAtoms; atom = res[i]->atom; k = 0; for (j=0;jname," CA ")) { k = 1; if (!atom[j]->altLoc[0]) { // take main conformation now as we do not know if // the specific one is in the file Calphas[nCalphas] = atom[j]; k = 2; } else if (atom[j]->altLoc[0]==altLoc[0]) { // get specific conformation and quit Calphas[nCalphas] = atom[j]; k = 2; break; } } else if (k) break; if (k==2) nCalphas++; } } } } else if (residue) { // check just this atom's residue Calphas = new PCAtom[1]; // can't be more than 1 C-alpha! nAtoms = residue->nAtoms; atom = residue->atom; if ((!altLoc[0]) || (altLoc[0]==' ')) { // main conformation for (j=0;jname," CA ")) { Calphas[nCalphas++] = atom[j]; break; } } else { // specific conformation k = 0; for (j=0;jname," CA ")) { k = 1; if (!atom[j]->altLoc[0]) { Calphas[nCalphas] = atom[j]; k = 2; } else if (atom[j]->altLoc[0]==altLoc[0]) { Calphas[nCalphas] = atom[j]; k = 2; break; } } else if (k) break; if (k==2) nCalphas++; } } if (Calphas && (!nCalphas)) { delete[] Calphas; Calphas = NULL; } } Boolean CAtom::isMetal() { return ::isMetal ( element ); } Boolean CAtom::isSolvent() { if (residue) return residue->isSolvent(); return False; } Boolean CAtom::isInSelection ( int selHnd ) { PCMMDBFile manager = (PCMMDBFile)GetCoordHierarchy(); PCMask Mask; if (manager) { Mask = manager->GetSelMask ( selHnd ); if (Mask) return CheckMask ( Mask ); } return False; } Boolean CAtom::isNTerminus() { if (residue) return residue->isNTerminus(); return False; } Boolean CAtom::isCTerminus() { if (residue) return residue->isCTerminus(); return False; } void CAtom::CalcAtomStatistics ( RSAtomStat AS ) { // AS must be initialized. The function only accumulates // the statistics. if (!Ter) { AS.nAtoms++; if (AS.WhatIsSet & WhatIsSet & ASET_Coordinates) { GetStat ( x,AS.xmin,AS.xmax,AS.xm,AS.xm2 ); GetStat ( y,AS.ymin,AS.ymax,AS.ym,AS.ym2 ); GetStat ( z,AS.zmin,AS.zmax,AS.zm,AS.zm2 ); } else AS.WhatIsSet &= ~ASET_Coordinates; if (AS.WhatIsSet & WhatIsSet & ASET_Occupancy) GetStat(occupancy,AS.occ_min,AS.occ_max,AS.occ_m,AS.occ_m2); else AS.WhatIsSet &= ~ASET_Occupancy; if (AS.WhatIsSet & WhatIsSet & ASET_tempFactor) GetStat ( tempFactor,AS.tFmin,AS.tFmax,AS.tFm,AS.tFm2 ); else AS.WhatIsSet &= ~ASET_tempFactor; if (AS.WhatIsSet & WhatIsSet & ASET_Anis_tFac) { GetStat ( u11,AS.u11_min,AS.u11_max,AS.u11_m,AS.u11_m2 ); GetStat ( u22,AS.u22_min,AS.u22_max,AS.u22_m,AS.u22_m2 ); GetStat ( u33,AS.u33_min,AS.u33_max,AS.u33_m,AS.u33_m2 ); GetStat ( u12,AS.u12_min,AS.u12_max,AS.u12_m,AS.u12_m2 ); GetStat ( u13,AS.u13_min,AS.u13_max,AS.u13_m,AS.u13_m2 ); GetStat ( u23,AS.u23_min,AS.u23_max,AS.u23_m,AS.u23_m2 ); } else AS.WhatIsSet &= ~ASET_Anis_tFac; } } realtype CAtom::GetDist2 ( PCAtom a ) { realtype dx,dy,dz; dx = a->x - x; dy = a->y - y; dz = a->z - z; return dx*dx + dy*dy + dz*dz; } realtype CAtom::GetDist2 ( PCAtom a, mat44 & tm ) { realtype dx,dy,dz; dx = tm[0][0]*a->x + tm[0][1]*a->y + tm[0][2]*a->z + tm[0][3] - x; dy = tm[1][0]*a->x + tm[1][1]*a->y + tm[1][2]*a->z + tm[1][3] - y; dz = tm[2][0]*a->x + tm[2][1]*a->y + tm[2][2]*a->z + tm[2][3] - z; return dx*dx + dy*dy + dz*dz; } realtype CAtom::GetDist2 ( PCAtom a, mat33 & r, vect3 & t ) { realtype dx,dy,dz; dx = r[0][0]*a->x + r[0][1]*a->y + r[0][2]*a->z + t[0] - x; dy = r[1][0]*a->x + r[1][1]*a->y + r[1][2]*a->z + t[1] - y; dz = r[2][0]*a->x + r[2][1]*a->y + r[2][2]*a->z + t[2] - z; return dx*dx + dy*dy + dz*dz; } realtype CAtom::GetDist2 ( realtype ax, realtype ay, realtype az ) { realtype dx,dy,dz; dx = ax - x; dy = ay - y; dz = az - z; return dx*dx + dy*dy + dz*dz; } realtype CAtom::GetCosine ( PCAtom a1, PCAtom a2 ) { // Calculates cosing of angle a1-this-a2, i.e. that between // bond [a1,this] and [this,a2]. realtype dx1,dy1,dz1, dx2,dy2,dz2,r; dx1 = a1->x - x; dy1 = a1->y - y; dz1 = a1->z - z; r = dx1*dx1 + dy1*dy1 + dz1*dz1; dx2 = a2->x - x; dy2 = a2->y - y; dz2 = a2->z - z; r *= dx2*dx2 + dy2*dy2 + dz2*dz2; if (r>0.0) return (dx1*dx2 + dy1*dy2 + dz1*dz2)/sqrt(r); else return 0.0; } void CAtom::MakeTer() { WhatIsSet |= ASET_Coordinates; Het = False; Ter = True; } void CAtom::SetAtomName ( const AtomName atomName ) { strcpy ( name,atomName ); } void CAtom::SetElementName ( const Element elName ) { strcpy ( element,elName ); if (!element[0]) strcpy ( element," " ); else if ((!element[1]) || (element[1]==' ')) { element[2] = char(0); element[1] = element[0]; element[0] = ' '; } } void CAtom::SetCharge ( cpstr chrg ) { pstr p; charge = strtod ( chrg,&p ); if (p!=chrg) { WhatIsSet |= ASET_Charge; if ((charge>0.0) && (*p=='-')) charge = -charge; } } void CAtom::SetCharge ( realtype chrg ) { if (chrgchain) { if (residue->chain->model) sprintf (AtomID,"/%i/",residue->chain->model->GetSerNum()); else strcpy ( AtomID,"/-/" ); strcat ( AtomID,residue->chain->chainID ); } else strcpy ( AtomID,"/-/-" ); ParamStr ( AtomID,pstr("/"),residue->seqNum ); if (residue->name[0]) { strcat ( AtomID,"(" ); strcat ( AtomID,residue->name ); strcat ( AtomID,")" ); } if (residue->insCode[0]) { strcat ( AtomID,"." ); strcat ( AtomID,residue->insCode ); } strcat ( AtomID,"/" ); } else strcpy ( AtomID,"/-/-/-/" ); strcpy_css ( S,name ); if (!S[0]) strcpy ( S,"-" ); strcat ( AtomID,S ); strcpy_css ( S,element ); if (S[0]) { strcat ( AtomID,"[" ); strcat ( AtomID,S ); strcat ( AtomID,"]" ); } if (altLoc[0]) { strcat ( AtomID,":" ); strcat ( AtomID,altLoc ); } return AtomID; } pstr CAtom::GetAtomIDfmt ( pstr AtomID ) { int n; char S[50]; AtomID[0] = char(0); if (residue) { if (residue->chain) { if (residue->chain->model) { n = residue->chain->model->GetNumberOfModels(); if (n<10) strcpy ( S,"/%1i/" ); else if (n<100) strcpy ( S,"/%2i/" ); else if (n<1000) strcpy ( S,"/%3i/" ); else strcpy ( S,"/%i/" ); sprintf ( AtomID,S,residue->chain->model->GetSerNum() ); } else strcpy ( AtomID,"/-/" ); strcat ( AtomID,residue->chain->chainID ); } else strcpy ( AtomID,"/-/-" ); if ((-999<=residue->seqNum) && (residue->seqNum<=9999)) sprintf ( S,"/%4i",residue->seqNum ); else sprintf ( S,"/%i" ,residue->seqNum ); strcat ( AtomID,S ); sprintf ( S,"(%3s).%1s/",residue->name,residue->insCode ); strcat ( AtomID,S ); } else strcpy ( AtomID,"/-/-/----(---).-/" ); sprintf ( S,"%4s[%2s]:%1s",name,element,altLoc ); strcat ( AtomID,S ); return AtomID; } int CAtom::ConvertPDBHETATM ( int ix, cpstr S ) { // Gets data from the PDB ASCII HETATM record. // This function DOES NOT check the "HETATM" keyword and // does not decode the chain and residue parameters! These // must be treated by the calling process, see // Chain::ConvertPDBASCII(). int RC; RC = ConvertPDBATOM ( ix,S ); Het = True; return RC; } void CAtom::GetData ( cpstr S ) { pstr p; if (((S[6]>='0') && (S[6]<='9')) || (S[6]==' ')) { // Here we forgive cards with unreadable serial numbers // as we always have index (ix) for the card. For the sake // of strict PDB syntax we would have to return // Error_UnrecognizedInteger here. if (!(GetInteger(serNum,&(S[6]),5))) serNum = -1; } else hy36decode ( 5,&(S[6]),5,&serNum ); // if (!(GetInteger(serNum,&(S[6]),5))) serNum = index; altLoc[0] = S[16]; if (altLoc[0]==' ') altLoc[0] = char(0); else altLoc[1] = char(0); GetString ( name ,&(S[12]),4 ); strcpy_ncss ( segID ,&(S[72]),4 ); GetString ( element,&(S[76]),2 ); charge = strtod ( &(S[78]),&p ); if ((charge!=0.0) && (p!=&(S[78]))) { WhatIsSet |= ASET_Charge; if ((charge>0.0) && (*p=='-')) charge = -charge; } RestoreElementName(); strcpy ( label_atom_id,name ); } int CAtom::CheckData ( cpstr S ) { int sN; AltLoc aloc; SegID sID; Element elmnt; pstr p; realtype achrg; aloc[0] = S[16]; if (aloc[0]==' ') aloc[0] = char(0); else aloc[1] = char(0); strcpy_ncss ( sID ,&(S[72]),4 ); GetString ( elmnt,&(S[76]),2 ); if (ignoreCharge) achrg = charge; else { achrg = strtod ( &(S[78]),&p ); if ((achrg!=0.0) && (p!=&(S[78]))) { if ((achrg>0.0) && (*p=='-')) achrg = -achrg; } } // if (!(GetInteger(sN,&(S[6]),5))) // sN = index; if (hy36decode(5,&(S[6]),5,&sN)) sN = index; if (ignoreSegID) { if (segID[0]) strcpy ( sID,segID ); else strcpy ( segID,sID ); } if (ignoreElement) { if (element[0]) strcpy ( elmnt,element ); else strcpy ( element,elmnt ); } if (ignoreUnmatch) return 0; // Here we forgive cards with unreadable serial numbers // as we always have index (ix) for the card. For the sake // of strict PDB syntax we would have to return // Error_UnrecognizedInteger . if ((sN!=serNum) || (strcmp (altLoc ,aloc )) || (strncmp(name ,&(S[12]),4)) || (strcmp (segID ,sID )) || (strcmp (element,elmnt )) || (charge!=achrg)) { /* char name1[100]; strncpy ( name1,&(S[12]),4 ); name1[4] = char(0); printf ( "\n serNum %5i %5i\n" " residue '%s' '%s'\n" " altLoc '%s' '%s'\n" " name '%s' '%s'\n" " segId '%s' '%s'\n" " element '%s' '%s'\n" " charge '%s' '%s'\n", sN,serNum, res->name,residue->name, altLoc ,aloc, name,name1, segID ,sID, element,elmnt, charge ,achrg ); if (res!=residue) printf (" it's a residue\n" ); */ return Error_ATOM_Unmatch; } return 0; } int CAtom::GetCIF ( int ix, PCMMCIFLoop Loop, PCMMCIFLoop LoopAnis ) { char PDBGroup[30]; int k; int RC; index = ix; if (WhatIsSet & ASET_Coordinates) return Error_ATOM_AlreadySet; /* loop_ *0 _atom_site.group_PDB *1 _atom_site.id *2 _atom_site.type_symbol <- chem elem -3 _atom_site.label_atom_id <- atom name *4 _atom_site.label_alt_id <- alt code =5 _atom_site.label_comp_id <- res name ??? =6 _atom_site.label_asym_id <- chain id ??? =7 _atom_site.label_entity_id < ??? =8 _atom_site.label_seq_id <- poly seq id +9 _atom_site.pdbx_PDB_ins_code <- ins code -10 _atom_site.segment_id <- segment id *11 _atom_site.Cartn_x *12 _atom_site.Cartn_y *13 _atom_site.Cartn_z *14 _atom_site.occupancy *15 _atom_site.B_iso_or_equiv *16 _atom_site.Cartn_x_esd *17 _atom_site.Cartn_y_esd *18 _atom_site.Cartn_z_esd *19 _atom_site.occupancy_esd *20 _atom_site.B_iso_or_equiv_esd *21 _atom_site.pdbx_formal_charge +22 _atom_site.auth_seq_id <- seq id we want +23 _atom_site.auth_comp_id <- res name we want +24 _atom_site.auth_asym_id <- ch id we want ? *25 _atom_site.auth_atom_id <- atom name we want ? +26 _atom_site.pdbx_PDB_model_num <- model no '+' read in CMMDBFile::CheckAtomPlace() '=' new in residue, read in CMMDBFile::CheckAtomPlace() '-' new in atom */ // (0) k = ix-1; CIFGetString ( PDBGroup,Loop,CIFTAG_GROUP_PDB,k, sizeof(PDBGroup),pstr("") ); Ter = !strcmp(PDBGroup,pstr("TER") ); Het = !strcmp(PDBGroup,pstr("HETATM")); // (1) RC = CIFGetInteger1 ( serNum,Loop,CIFTAG_ID,k ); if (RC) { if (Ter) serNum = -1; else if (RC==Error_NoData) serNum = index; else return RC; } if (Ter) { Loop->DeleteRow ( k ); WhatIsSet |= ASET_Coordinates; return 0; } // (25) CIFGetString ( name,Loop,CIFTAG_AUTH_ATOM_ID,k, sizeof(name) ,pstr("") ); // (3) CIFGetString ( label_atom_id,Loop,CIFTAG_LABEL_ATOM_ID,k, sizeof(label_atom_id),pstr("") ); // (4) CIFGetString ( altLoc,Loop,CIFTAG_LABEL_ALT_ID ,k, sizeof(altLoc),pstr("") ); // (11,12,13) RC = CIFGetReal1 ( x,Loop,CIFTAG_CARTN_X,k ); if (!RC) RC = CIFGetReal1 ( y,Loop,CIFTAG_CARTN_Y,k ); if (!RC) RC = CIFGetReal1 ( z,Loop,CIFTAG_CARTN_Z,k ); if (RC) return Error_ATOM_Unrecognized; WhatIsSet |= ASET_Coordinates; // (14) if (!CIFGetReal1(occupancy,Loop,CIFTAG_OCCUPANCY,k)) WhatIsSet |= ASET_Occupancy; // (15) if (!CIFGetReal1(tempFactor,Loop,CIFTAG_B_ISO_OR_EQUIV,k)) WhatIsSet |= ASET_tempFactor; // (10) CIFGetString ( segID,Loop,CIFTAG_SEGMENT_ID,k, sizeof(segID) ,pstr("") ); // (21) if (!CIFGetReal1(charge,Loop,CIFTAG_PDBX_FORMAL_CHARGE,k)) WhatIsSet |= ASET_Charge; // (2) RC = CIFGetString ( element,Loop,CIFTAG_TYPE_SYMBOL,k, sizeof(element),pstr(" ") ); if (RC) CIFGetString ( element,Loop,CIFTAG_ATOM_TYPE_SYMBOL,k, sizeof(element),pstr(" ") ); RestoreElementName(); MakePDBAtomName (); // printf ( " '%s' '%s'\n",name,element ); // (16,17,18) RC = CIFGetReal1 ( sigX,Loop,CIFTAG_CARTN_X_ESD,k ); if (!RC) RC = CIFGetReal1 ( sigY,Loop,CIFTAG_CARTN_Y_ESD,k ); if (!RC) RC = CIFGetReal1 ( sigZ,Loop,CIFTAG_CARTN_Z_ESD,k ); if (RC==Error_UnrecognizedReal) return RC; if (!RC) WhatIsSet |= ASET_CoordSigma; // (19) if (!CIFGetReal1(sigOcc,Loop,CIFTAG_OCCUPANCY_ESD,k)) WhatIsSet |= ASET_OccSigma; // (20) if (!CIFGetReal1(sigTemp,Loop,CIFTAG_B_ISO_OR_EQUIV_ESD,k)) WhatIsSet |= ASET_tFacSigma; Loop->DeleteRow ( k ); if (LoopAnis) { RC = CIFGetReal1 ( u11,LoopAnis,CIFTAG_U11,k ); if (!RC) RC = CIFGetReal1 ( u22,LoopAnis,CIFTAG_U22,k ); if (!RC) RC = CIFGetReal1 ( u33,LoopAnis,CIFTAG_U33,k ); if (!RC) RC = CIFGetReal1 ( u13,LoopAnis,CIFTAG_U13,k ); if (!RC) RC = CIFGetReal1 ( u12,LoopAnis,CIFTAG_U12,k ); if (!RC) RC = CIFGetReal1 ( u23,LoopAnis,CIFTAG_U23,k ); if (RC==Error_UnrecognizedReal) return RC; if (!RC) WhatIsSet |= ASET_Anis_tFac; RC = CIFGetReal1 ( su11,LoopAnis,CIFTAG_U11_ESD,k ); if (!RC) RC = CIFGetReal1 ( su22,LoopAnis,CIFTAG_U22_ESD,k ); if (!RC) RC = CIFGetReal1 ( su33,LoopAnis,CIFTAG_U33_ESD,k ); if (!RC) RC = CIFGetReal1 ( su13,LoopAnis,CIFTAG_U13_ESD,k ); if (!RC) RC = CIFGetReal1 ( su12,LoopAnis,CIFTAG_U12_ESD,k ); if (!RC) RC = CIFGetReal1 ( su23,LoopAnis,CIFTAG_U23_ESD,k ); if (RC==Error_UnrecognizedReal) return RC; if (!RC) WhatIsSet |= ASET_Anis_tFSigma; LoopAnis->DeleteRow ( k ); } return 0; } Boolean CAtom::RestoreElementName() { // This function works only if element name is not given. if (Ter) { name[0] = char(0); element[0] = char(0); return False; } if ((!element[0]) || ((element[0]==' ') && ((!element[1]) || (element[1]==' ')))) { if ((name[0]>='A') && (name[0]<='Z')) { element[0] = name[0]; element[1] = name[1]; } else { element[0] = ' '; element[1] = name[1]; } element[2] = char(0); return False; } else if (!element[1]) { // not aligned element name, possibly coming from mmCIF element[1] = element[0]; element[0] = ' '; element[2] = char(0); return False; } return True; } Boolean CAtom::MakePDBAtomName() { int i,k; if (Ter) { name[0] = char(0); element[0] = char(0); return False; } UpperCase ( name ); UpperCase ( element ); if ((element[0]==' ') && (element[1]==' ')) { // element name not given, make one from the atom name if ((name[0]>='A') && (name[0]<='Z')) { if (!name[1]) { name[4] = char(0); name[3] = ' '; name[2] = ' '; name[1] = name[0]; name[0] = ' '; } /* the commented part looks like a wrong inheritance from FORTRAN RWBrook. Commented on 04.03.2004, to be removed. else if ((name[0]=='C') && (name[1]=='A')) { name[4] = char(0); name[3] = name[2]; name[2] = name[1]; name[1] = name[0]; name[0] = ' '; } */ element[0] = name[0]; element[1] = name[1]; } else { element[0] = ' '; element[1] = name[1]; } element[2] = char(0); return False; } else if ((name[0]>='A') && (name[0]<='Z')) { if (!element[1]) { element[2] = char(0); element[1] = element[0]; element[0] = ' '; k = strlen(name); if (k<4) { for (i=3;i>0;i--) name[i] = name[i-1]; name[0] = ' '; k++; while (k<4) name[k++] = ' '; name[k] = char(0); } } else if ((element[0]==' ') && (element[1]!=name[1])) { for (i=3;i>0;i--) name[i] = name[i-1]; name[0] = ' '; k = strlen(name); while (k<4) name[k++] = ' '; name[k] = char(0); } else { k = strlen(name); while (k<4) name[k++] = ' '; name[k] = char(0); } } return True; } void CAtom::SetCoordinates ( realtype xx, realtype yy, realtype zz, realtype occ, realtype tFac ) { x = xx; y = yy; z = zz; occupancy = occ; tempFactor = tFac; WhatIsSet |= ASET_Coordinates | ASET_Occupancy | ASET_tempFactor; } void CAtom::Transform ( mat33 & tm, vect3 & v ) { realtype x1,y1,z1; x1 = tm[0][0]*x + tm[0][1]*y + tm[0][2]*z + v[0]; y1 = tm[1][0]*x + tm[1][1]*y + tm[1][2]*z + v[1]; z1 = tm[2][0]*x + tm[2][1]*y + tm[2][2]*z + v[2]; x = x1; y = y1; z = z1; } void CAtom::Transform ( mat44 & tm ) { realtype x1,y1,z1; x1 = tm[0][0]*x + tm[0][1]*y + tm[0][2]*z + tm[0][3]; y1 = tm[1][0]*x + tm[1][1]*y + tm[1][2]*z + tm[1][3]; z1 = tm[2][0]*x + tm[2][1]*y + tm[2][2]*z + tm[2][3]; x = x1; y = y1; z = z1; } void CAtom::TransformCopy ( mat44 & tm, realtype & xx, realtype & yy, realtype & zz ) { xx = tm[0][0]*x + tm[0][1]*y + tm[0][2]*z + tm[0][3]; yy = tm[1][0]*x + tm[1][1]*y + tm[1][2]*z + tm[1][3]; zz = tm[2][0]*x + tm[2][1]*y + tm[2][2]*z + tm[2][3]; } void CAtom::TransformSet ( mat44 & tm, realtype xx, realtype yy, realtype zz ) { x = tm[0][0]*xx + tm[0][1]*yy + tm[0][2]*zz + tm[0][3]; y = tm[1][0]*xx + tm[1][1]*yy + tm[1][2]*zz + tm[1][3]; z = tm[2][0]*xx + tm[2][1]*yy + tm[2][2]*zz + tm[2][3]; } // ------- user-defined data handlers int CAtom::PutUDData ( int UDDhandle, int iudd ) { if (UDDhandle & UDRF_ATOM) return CUDData::putUDData ( UDDhandle,iudd ); else return UDDATA_WrongUDRType; } int CAtom::PutUDData ( int UDDhandle, realtype rudd ) { if (UDDhandle & UDRF_ATOM) return CUDData::putUDData ( UDDhandle,rudd ); else return UDDATA_WrongUDRType; } int CAtom::PutUDData ( int UDDhandle, cpstr sudd ) { if (UDDhandle & UDRF_ATOM) return CUDData::putUDData ( UDDhandle,sudd ); else return UDDATA_WrongUDRType; } int CAtom::GetUDData ( int UDDhandle, int & iudd ) { if (UDDhandle & UDRF_ATOM) return CUDData::getUDData ( UDDhandle,iudd ); else return UDDATA_WrongUDRType; } int CAtom::GetUDData ( int UDDhandle, realtype & rudd ) { if (UDDhandle & UDRF_ATOM) return CUDData::getUDData ( UDDhandle,rudd ); else return UDDATA_WrongUDRType; } int CAtom::GetUDData ( int UDDhandle, pstr sudd, int maxLen ) { if (UDDhandle & UDRF_ATOM) return CUDData::getUDData ( UDDhandle,sudd,maxLen ); else return UDDATA_WrongUDRType; } int CAtom::GetUDData ( int UDDhandle, pstr & sudd ) { if (UDDhandle & UDRF_ATOM) return CUDData::getUDData ( UDDhandle,sudd ); else return UDDATA_WrongUDRType; } void CAtom::Copy ( PCAtom atom ) { // this does not make any references in residues and does // not change indices!! it does change serial numbers, though. serNum = atom->serNum; x = atom->x; y = atom->y; z = atom->z; occupancy = atom->occupancy; tempFactor = atom->tempFactor; sigX = atom->sigX; sigY = atom->sigY; sigZ = atom->sigZ; sigOcc = atom->sigOcc; sigTemp = atom->sigTemp; u11 = atom->u11; u22 = atom->u22; u33 = atom->u33; u12 = atom->u12; u13 = atom->u13; u23 = atom->u23; su11 = atom->su11; su22 = atom->su22; su33 = atom->su33; su12 = atom->su12; su13 = atom->su13; su23 = atom->su23; Het = atom->Het; Ter = atom->Ter; WhatIsSet = atom->WhatIsSet; strcpy ( name ,atom->name ); strcpy ( label_atom_id,atom->label_atom_id ); strcpy ( altLoc ,atom->altLoc ); strcpy ( segID ,atom->segID ); strcpy ( element ,atom->element ); strcpy ( energyType ,atom->energyType ); charge = atom->charge; } int CAtom::CheckID ( const AtomName aname, const Element elname, const AltLoc aloc ) { pstr p1,p2; if (aname) { if (aname[0]!='*') { p1 = name; while (*p1==' ') p1++; p2 = pstr(aname); while (*p2==' ') p2++; while ((*p2) && (*p1) && (*p1!=' ') && (*p2!=' ')) { if (*p1!=*p2) return 0; p1++; p2++; } if (*p1!=*p2) { if (((*p1) && (*p1!=' ')) || ((*p2) && (*p2!=' '))) return 0; } } } if (elname) { if (elname[0]!='*') { p1 = element; while (*p1==' ') p1++; p2 = pstr(elname); while (*p2==' ') p2++; while ((*p2) && (*p1) && (*p1!=' ') && (*p2!=' ')) { if (*p1!=*p2) return 0; p1++; p2++; } if (*p1!=*p2) return 0; } } if (aloc) { if ((aloc[0]!='*') && (strcmp(aloc,altLoc))) return 0; } return 1; } int CAtom::CheckIDS ( cpstr ID ) { AtomName aname; Element elname; AltLoc aloc; pstr p; p = strrchr ( ID,'/' ); if (p) p++; else p = pstr(ID); ParseAtomID ( p,aname,elname,aloc ); return CheckID ( aname,elname,aloc ); } void CAtom::SetShortBinary() { WhatIsSet |= ASET_ShortBinary; } void CAtom::write ( RCFile f ) { int i,k; byte Version=2; byte nb; f.WriteWord ( &WhatIsSet ); if (WhatIsSet & ASET_ShortBinary) { if (Ter) WhatIsSet |= ASET_ShortTer; if (Het) WhatIsSet |= ASET_ShortHet; f.WriteInt ( &index ); f.WriteTerLine ( name ,False ); f.WriteTerLine ( altLoc ,False ); f.WriteTerLine ( element,False ); if (WhatIsSet & ASET_Coordinates) { f.WriteFloat ( &x ); f.WriteFloat ( &y ); f.WriteFloat ( &z ); } return; } f.WriteByte ( &Version ); CUDData::write ( f ); f.WriteInt ( &serNum ); f.WriteInt ( &index ); f.WriteTerLine ( name ,False ); f.WriteTerLine ( label_atom_id,False ); f.WriteTerLine ( altLoc ,False ); f.WriteTerLine ( segID ,False ); f.WriteTerLine ( element ,False ); f.WriteTerLine ( energyType ,False ); f.WriteFloat ( &charge ); f.WriteBool ( &Het ); f.WriteBool ( &Ter ); if (WhatIsSet & ASET_Coordinates) { f.WriteFloat ( &x ); f.WriteFloat ( &y ); f.WriteFloat ( &z ); if (WhatIsSet & ASET_Occupancy) f.WriteFloat ( &occupancy ); if (WhatIsSet & ASET_tempFactor) f.WriteFloat ( &tempFactor ); } if (WhatIsSet & ASET_CoordSigma) { f.WriteFloat ( &sigX ); f.WriteFloat ( &sigY ); f.WriteFloat ( &sigZ ); if ((WhatIsSet & ASET_Occupancy) && (WhatIsSet & ASET_OccSigma)) f.WriteFloat ( &sigOcc ); if ((WhatIsSet & ASET_tempFactor) && (WhatIsSet & ASET_tFacSigma)) f.WriteFloat ( &sigTemp ); } if (WhatIsSet & ASET_Anis_tFac) { f.WriteFloat ( &u11 ); f.WriteFloat ( &u22 ); f.WriteFloat ( &u33 ); f.WriteFloat ( &u12 ); f.WriteFloat ( &u13 ); f.WriteFloat ( &u23 ); if (WhatIsSet & ASET_Anis_tFSigma) { f.WriteFloat ( &su11 ); f.WriteFloat ( &su22 ); f.WriteFloat ( &su33 ); f.WriteFloat ( &su12 ); f.WriteFloat ( &su13 ); f.WriteFloat ( &su23 ); } } nb = byte(nBonds & 0x000000FF); f.WriteByte ( &nb ); for (i=0;iindex) ); f.WriteByte ( &(Bond[i].order) ); } else { k = -1; f.WriteInt ( &k ); } } void CAtom::read ( RCFile f ) { int i,k; byte nb,Version; FreeMemory(); f.ReadWord ( &WhatIsSet ); if (WhatIsSet & ASET_ShortBinary) { f.ReadInt ( &index ); f.ReadTerLine ( name ,False ); f.ReadTerLine ( altLoc ,False ); f.ReadTerLine ( element,False ); if (WhatIsSet & ASET_Coordinates) { f.ReadFloat ( &x ); f.ReadFloat ( &y ); f.ReadFloat ( &z ); } serNum = index; Ter = WhatIsSet & ASET_ShortTer; Het = WhatIsSet & ASET_ShortHet; name [4] = char(0); altLoc [1] = char(0); element[2] = char(0); segID [0] = char(0); charge = 0.0; WhatIsSet &= ASET_All; return; } f.ReadByte ( &Version ); CUDData::read ( f ); f.ReadInt ( &serNum ); f.ReadInt ( &index ); f.ReadTerLine ( name ,False ); if (Version>1) f.ReadTerLine ( label_atom_id,False ); f.ReadTerLine ( altLoc ,False ); f.ReadTerLine ( segID ,False ); f.ReadTerLine ( element ,False ); f.ReadTerLine ( energyType,False ); f.ReadFloat ( &charge ); f.ReadBool ( &Het ); f.ReadBool ( &Ter ); if (WhatIsSet & ASET_Coordinates) { f.ReadFloat ( &x ); f.ReadFloat ( &y ); f.ReadFloat ( &z ); if (WhatIsSet & ASET_Occupancy) f.ReadFloat ( &occupancy ); else occupancy = 0.0; if (WhatIsSet & ASET_tempFactor) f.ReadFloat ( &tempFactor ); else tempFactor = 0.0; } else { x = 0.0; y = 0.0; z = 0.0; occupancy = 0.0; tempFactor = 0.0; } if (WhatIsSet & ASET_CoordSigma) { f.ReadFloat ( &sigX ); f.ReadFloat ( &sigY ); f.ReadFloat ( &sigZ ); if ((WhatIsSet & ASET_Occupancy) && (WhatIsSet & ASET_OccSigma)) f.ReadFloat ( &sigOcc ); else sigOcc = 0.0; if ((WhatIsSet & ASET_tempFactor) && (WhatIsSet & ASET_tFacSigma)) f.ReadFloat ( &sigTemp ); else sigTemp = 0.0; } else { sigX = 0.0; sigY = 0.0; sigZ = 0.0; sigOcc = 0.0; sigTemp = 0.0; } if (WhatIsSet & ASET_Anis_tFac) { f.ReadFloat ( &u11 ); f.ReadFloat ( &u22 ); f.ReadFloat ( &u33 ); f.ReadFloat ( &u12 ); f.ReadFloat ( &u13 ); f.ReadFloat ( &u23 ); if (WhatIsSet & ASET_Anis_tFSigma) { f.ReadFloat ( &su11 ); f.ReadFloat ( &su22 ); f.ReadFloat ( &su33 ); f.ReadFloat ( &su12 ); f.ReadFloat ( &su13 ); f.ReadFloat ( &su23 ); } else { su11 = 0.0; su22 = 0.0; su33 = 0.0; su12 = 0.0; su13 = 0.0; su23 = 0.0; } } else { u11 = 0.0; u22 = 0.0; u33 = 0.0; u12 = 0.0; u13 = 0.0; u23 = 0.0; su11 = 0.0; su22 = 0.0; su33 = 0.0; su12 = 0.0; su13 = 0.0; su23 = 0.0; } f.ReadByte ( &nb ); if (nb>0) { Bond = new SAtomBond[nb]; for (i=0;i0) f.ReadByte ( &(Bond[i].order) ); else Bond[i].order = 0; // we place *index* of bonded atom temporary on the place // of its pointer, and the pointer will be calculated // after CResidue::read calls _setBonds(..). memcpy ( &(Bond[i].atom),&k,4 ); } } nBonds = nb; nBonds = nBonds | (nBonds << 8); } void CAtom::_setBonds ( PPCAtom A ) { int i,k,nb; nb = nBonds & 0x000000FF; for (i=0;i0) Bond[i].atom = A[k]; else Bond[i].atom = NULL; } } MakeFactoryFunctions(CAtom) // =========================== CResidue =========================== void SAtomStat::Init() { nAtoms = 0; xmin = MaxReal; xmax = MinReal; xm = 0.0; xm2 = 0.0; ymin = MaxReal; ymax = MinReal; ym = 0.0; ym2 = 0.0; zmin = MaxReal; zmax = MinReal; zm = 0.0; zm2 = 0.0; occ_min = MaxReal; occ_max = MinReal; occ_m = 0.0; occ_m2 = 0.0; tFmin = MaxReal; tFmax = MinReal; tFm = 0.0; tFm2 = 0.0; u11_min = MaxReal; u11_max = MinReal; u11_m = 0.0; u11_m2 = 0.0; u22_min = MaxReal; u22_max = MinReal; u22_m = 0.0; u22_m2 = 0.0; u33_min = MaxReal; u33_max = MinReal; u33_m = 0.0; u33_m2 = 0.0; u12_min = MaxReal; u12_max = MinReal; u12_m = 0.0; u12_m2 = 0.0; u13_min = MaxReal; u13_max = MinReal; u13_m = 0.0; u13_m2 = 0.0; u23_min = MaxReal; u23_max = MinReal; u23_m = 0.0; u23_m2 = 0.0; WhatIsSet = ASET_All; finished = False; } void SAtomStat::Finish() { realtype v; if (!finished) { finished = True; if (nAtoms>0) { v = nAtoms; xm /= v; xm2 /= v; ym /= v; ym2 /= v; zm /= v; zm2 /= v; occ_m /= v; occ_m2 /= v; tFm /= v; tFm2 /= v; u11_m /= v; u11_m2 /= v; u22_m /= v; u22_m2 /= v; u33_m /= v; u33_m2 /= v; u12_m /= v; u12_m2 /= v; u13_m /= v; u13_m2 /= v; u23_m /= v; u23_m2 /= v; } } } realtype SAtomStat::GetMaxSize() { realtype r; r = RMax(xmax-xmin,ymax-ymin); r = RMax(r,zmax-zmin); return RMax(r,0.0); } // ---------------------------------------------------------------- CResidue::CResidue() : CUDData() { InitResidue(); } CResidue::CResidue ( PCChain Chain_Owner ) : CUDData() { InitResidue(); if (Chain_Owner) Chain_Owner->AddResidue ( this ); } CResidue::CResidue ( PCChain Chain_Owner, const ResName resName, int sqNum, const InsCode ins ) : CUDData() { InitResidue(); seqNum = sqNum; strcpy_css ( name,pstr(resName) ); strcpy_css ( insCode,pstr(ins) ); if (Chain_Owner) Chain_Owner->AddResidue ( this ); } CResidue::CResidue ( RPCStream Object ) : CUDData(Object) { InitResidue(); } CResidue::~CResidue() { FreeMemory(); if (chain) chain->_ExcludeResidue ( name,seqNum,insCode ); } void CResidue::InitResidue() { strcpy ( name ,"---" ); // residue name strcpy ( label_comp_id,"---" ); // assigned residue name label_asym_id[0] = char(0); // assigned chain Id seqNum = -MaxInt; // residue sequence number label_seq_id = -MaxInt; // assigned residue sequence number label_entity_id = 1; // assigned entity id strcpy ( insCode,"" ); // residue insertion code chain = NULL; // reference to chain index = -1; // undefined index in chain nAtoms = 0; // number of atoms in the residue AtmLen = 0; // length of atom array atom = NULL; // array of atoms Exclude = True; SSE = SSE_None; } void CResidue::SetChain ( PCChain Chain_Owner ) { chain = Chain_Owner; } int CResidue::GetResidueNo() { if (chain) return chain->GetResidueNo ( seqNum,insCode ); else return -1; } void CResidue::SetChainID ( const ChainID chID ) { if (chain) chain->SetChainID ( chID ); } int CResidue::GetCenter ( realtype & x, realtype & y, realtype & z ) { int i,k; x = 0.0; y = 0.0; z = 0.0; k = 0; for (i=0;iTer) { x += atom[i]->x; y += atom[i]->y; z += atom[i]->z; k++; } } if (k>0) { x /= k; y /= k; z /= k; return 0; } return 1; } void * CResidue::GetCoordHierarchy() { if (chain) return chain->GetCoordHierarchy(); return NULL; } void CResidue::GetAltLocations ( int & nAltLocs, PAltLoc & aLoc, rvector & occupancy, int & alflag ) { int i,j,k, nal,nal1; realtype occ1; Boolean B; PAltLoc aL; rvector occ; bvector alv; aLoc = NULL; occupancy = NULL; nAltLocs = 0; alflag = ALF_NoAltCodes; if (nAtoms>0) { // temporary array for altcodes aL = new AltLoc[nAtoms]; // temporary array for occupancies GetVectorMemory ( occ,nAtoms,0 ); // temporary array for checking altcodes GetVectorMemory ( alv,nAtoms,0 ); for (i=0;iTer) { // Find if the alternation code of ith atom is // a new one. B = False; for (j=0;(jaltLoc,aL[j]); if (!B) { // that's a new altcode, get its occupancy if (atom[i]->WhatIsSet & ASET_Occupancy) occ[k] = atom[i]->occupancy; else occ[k] = -1.0; // store new altcode in temporary array strcpy ( aL[k],atom[i]->altLoc ); // check consistency of the altcode data if: // a) the data was not found wrong so far // b) this atom name has not been checked before // c) altcode is not the "empty"-altcode if ((!(alflag & ALF_Mess)) && (!alv[i]) && (atom[i]->altLoc[0])) { B = False; // will be set True if "empty"-altcode // is found for current atom name nal1 = 0; // counts the number of different altcodes // for current atom name occ1 = 0.0; // will count the sum of occupancies for // current atom name for (j=0;jTer) && (!strcmp(atom[j]->name,atom[i]->name))) { if (atom[j]->WhatIsSet & ASET_Occupancy) occ1 += atom[j]->occupancy; if (!atom[j]->altLoc[0]) B = True; alv[j] = True; // mark it as "checked" nal1++; } } if (!(alflag & (ALF_EmptyAltLoc | ALF_NoEmptyAltLoc))) { if (B) alflag |= ALF_EmptyAltLoc; else alflag |= ALF_NoEmptyAltLoc; } else if (((alflag & ALF_EmptyAltLoc) && (!B)) || ((alflag & ALF_NoEmptyAltLoc) && (B))) alflag |= ALF_Mess; if ((occ[k]>=0) && (fabs(1.0-occ1)>0.01)) alflag |= ALF_Occupancy; if (nal==0) // first time just remember the number nal = nal1; // of different altcodes else if (nal!=nal1) // check if number of different altcodes alflag |= ALF_Mess; // is not the same through the residue } k++; } } } if (k>0) { aLoc = new AltLoc[k]; GetVectorMemory ( occupancy,k,0 ); for (i=0;iTer) { B = False; for (j=0;(jTer) B = !strcmp(atom[i]->altLoc,atom[j]->altLoc); } if (!B) k++; } } return k; } void CResidue::SetResID ( const ResName resName, int sqNum, const InsCode ins ) { strcpy_css ( name,pstr(resName) ); seqNum = sqNum; strcpy_css ( insCode,pstr(ins) ); strcpy (label_comp_id,name ); } void CResidue::FreeMemory() { // NOTE: individual atoms are disposed here as well! DeleteAllAtoms(); if (atom) delete[] atom; atom = NULL; nAtoms = 0; AtmLen = 0; } void CResidue::ExpandAtomArray ( int nAdd ) { int i; PPCAtom atom1; AtmLen += abs(nAdd); atom1 = new PCAtom[AtmLen]; for (i=0;i=AtmLen) ExpandAtomArray ( nAtoms+10-AtmLen ); atom[nAtoms] = atm; atom[nAtoms]->residue = this; nAtoms++; return 0; } int CResidue::AddAtom ( PCAtom atm ) { // AddAtom(..) adds atom to the residue. If residue is associated // with a coordinate hierarchy, and atom 'atm' is not, the latter // is checked in automatically. If atom 'atm' belongs to any // coordinate hierarchy (even though that of the residue), it is // *copied* rather than simply taken over, and is checked in. // If residue is not associated with a coordinate hierarchy, all // added atoms will be checked in automatically once the residue // is checked in. PCMMDBFile manager; PCResidue res; int i; for (i=0;i=AtmLen) ExpandAtomArray ( nAtoms+10-AtmLen ); if (atm->GetCoordHierarchy()) { atom[nAtoms] = newCAtom(); atom[nAtoms]->Copy ( atm ); } else { res = atm->GetResidue(); if (res) for (i=0;inAtoms;i++) if (res->atom[i]==atm) { res->atom[i] = NULL; break; } atom[nAtoms] = atm; } atom[nAtoms]->residue = this; manager = PCMMDBFile(GetCoordHierarchy()); if (manager) manager->CheckInAtom ( 0,atom[nAtoms] ); nAtoms++; return nAtoms; } int CResidue::InsertAtom ( PCAtom atm, int position ) { // InsertAtom(..) inserts atom into the specified position of // the residue. If residue is associated with a coordinate hierarchy, // and atom 'atm' is not, the latter is checked in automatically. // If atom 'atm' belongs to any coordinate hierarchy (even though // that of the residue), it is *copied* rather than simply taken // over, and is checked in. // If residue is not associated with a coordinate hierarchy, all // added atoms will be checked in automatically once the residue // is checked in. PCMMDBFile manager; PCResidue res; int i,pos; for (i=0;i=AtmLen) ExpandAtomArray ( nAtoms+10-AtmLen ); pos = IMin(position,nAtoms); for (i=nAtoms;i>pos;i--) atom[i] = atom[i-1]; if (atm->GetCoordHierarchy()) { atom[pos] = newCAtom(); atom[pos]->Copy ( atm ); } else { res = atm->GetResidue(); if (res) for (i=0;inAtoms;i++) if (res->atom[i]==atm) { res->atom[i] = NULL; break; } atom[pos] = atm; } atom[pos]->residue = this; manager = PCMMDBFile(GetCoordHierarchy()); if (manager) manager->CheckInAtom ( 0,atom[pos] ); nAtoms++; return nAtoms; } int CResidue::InsertAtom ( PCAtom atm, const AtomName aname ) { // This version inserts before the atom with given name. If such // name is not found, the atom is appended to the end. int i; i = 0; while (iname)) break; else i++; return InsertAtom ( atm,i ); } void CResidue::CheckInAtoms() { PCMMDBFile manager; int i; manager = PCMMDBFile(GetCoordHierarchy()); if (manager) for (i=0;iindex<0) manager->CheckInAtom ( 0,atom[i] ); } } int CResidue::_ExcludeAtom ( int kndex ) { // deletes atom from the residue int i,k; if (!Exclude) return 0; k = -1; for (i=0;(iindex==kndex) k = i; } if (k>=0) { for (i=k+1;iPDBASCIIDump ( f ); } void CResidue::MakeAtomCIF ( PCMMCIFData CIF ) { int i; for (i=0;iMakeCIF ( CIF ); } void CResidue::Copy ( PCResidue res ) { // // Modify CResidue::Copy and both CResidues::_copy methods // simultaneously! // // This function will nake a copy of residue res in 'this' one. // All atoms are copied, none is moved regardless to the association // with coordinate hierarchy. If 'this' residue is associated with // a coordinate hierarchy, all atoms are checked in. PCMMDBFile manager; int i; FreeMemory(); seqNum = res->seqNum; label_seq_id = res->label_seq_id; label_entity_id = res->label_entity_id; index = res->index; AtmLen = res->nAtoms; SSE = res->SSE; strcpy ( name ,res->name ); strcpy ( label_comp_id,res->label_comp_id ); strcpy ( label_asym_id,res->label_asym_id ); strcpy ( insCode ,res->insCode ); if (AtmLen>0) { atom = new PCAtom[AtmLen]; nAtoms = 0; for (i=0;inAtoms;i++) if (res->atom[i]) { atom[nAtoms] = newCAtom(); atom[nAtoms]->Copy ( res->atom[i] ); atom[nAtoms]->SetResidue ( this ); nAtoms++; } for (i=nAtoms;iCheckInAtoms ( 0,atom,nAtoms ); } } void CResidue::_copy ( PCResidue res ) { // Modify both CResidue::_copy and CResidue::Copy methods // simultaneously! // // will work properly only if atomic arrays // this->chain->model->GetAtom() and // res->chain->model->GetAtom() are identical // int i; PPCAtom A; FreeMemory(); seqNum = res->seqNum; label_seq_id = res->label_seq_id; label_entity_id = res->label_entity_id; index = res->index; nAtoms = res->nAtoms; SSE = res->SSE; strcpy ( name ,res->name ); strcpy ( label_comp_id,res->label_comp_id ); strcpy ( label_asym_id,res->label_asym_id ); strcpy ( insCode ,res->insCode ); AtmLen = nAtoms; A = NULL; if (chain) { if (chain->model) A = chain->model->GetAllAtoms(); } if ((nAtoms>0) && (A)) { atom = new PCAtom[nAtoms]; for (i=0;iatom[i]->index-1]; atom[i]->SetResidue ( this ); } } else { nAtoms = 0; AtmLen = 0; } } void CResidue::_copy ( PCResidue res, PPCAtom atm, int & atom_index ) { // modify both CResidue::_copy and CResidue::Copy methods // simultaneously! // // This function physically copies the atoms, creating new atom // instances and putting them into array 'atm' sequentially from // 'atom_index' position. 'atom_index' is modified (advanced). // int i; FreeMemory(); seqNum = res->seqNum; label_seq_id = res->label_seq_id; label_entity_id = res->label_entity_id; index = res->index; nAtoms = res->nAtoms; SSE = res->SSE; strcpy ( name ,res->name ); strcpy ( label_comp_id,res->label_comp_id ); strcpy ( label_asym_id,res->label_asym_id ); strcpy ( insCode ,res->insCode ); AtmLen = nAtoms; if (AtmLen>0) { atom = new PCAtom[AtmLen]; for (i=0;iatom[i]) { if (!atm[atom_index]) atm[atom_index] = newCAtom(); atm[atom_index]->Copy ( res->atom[i] ); atm[atom_index]->residue = this; atm[atom_index]->index = atom_index+1; atom[i] = atm[atom_index]; atom_index++; } else atom[i] = NULL; } } void CResidue::GetAtomStatistics ( RSAtomStat AS ) { AS.Init(); CalcAtomStatistics ( AS ); AS.Finish(); } void CResidue::CalcAtomStatistics ( RSAtomStat AS ) { // AS must be initialized. The function only accumulates // the statistics. int i; for (i=0;iCalcAtomStatistics ( AS ); } PCChain CResidue::GetChain() { return chain; } PCModel CResidue::GetModel() { if (chain) return (PCModel)chain->model; else return NULL; } int CResidue::GetModelNum() { if (chain) { if (chain->model) return chain->model->GetSerNum(); } return 0; } pstr CResidue::GetChainID() { if (chain) return chain->chainID; return pstr(""); } pstr CResidue::GetLabelAsymID() { return label_asym_id; } pstr CResidue::GetResName() { return name; } pstr CResidue::GetLabelCompID() { return label_comp_id; } int CResidue::GetAASimilarity ( const ResName resName ) { return ::GetAASimilarity ( pstr(name),pstr(resName) ); } int CResidue::GetAASimilarity ( PCResidue res ) { return ::GetAASimilarity ( name,res->name ); } realtype CResidue::GetAAHydropathy() { return ::GetAAHydropathy ( name ); } void CResidue::SetResName ( const ResName resName ) { strcpy ( name,resName ); } int CResidue::GetSeqNum() { return seqNum; } int CResidue::GetLabelSeqID() { return label_seq_id; } int CResidue::GetLabelEntityID() { return label_entity_id; } pstr CResidue::GetInsCode() { return insCode; } Boolean CResidue::isAminoacid () { return ::isAminoacid ( name ); } Boolean CResidue::isNucleotide() { return ::isNucleotide ( name ); } int CResidue::isDNARNA() { return ::isDNARNA ( name ); } Boolean CResidue::isSugar() { return ::isSugar ( name ); } Boolean CResidue::isSolvent() { return ::isSolvent ( name ); } Boolean CResidue::isModRes() { PCChain chn; PCModRes modRes; int nModRes,i; chn = GetChain(); if (chn) { nModRes = chn->GetNofModResidues(); for (i=0;iGetModResidue ( i ); if (modRes) { if ((!strcmp(modRes->resName,name)) && (modRes->seqNum==seqNum) && (!strcmp(modRes->insCode,insCode))) return True; } } } return False; } Boolean CResidue::isInSelection ( int selHnd ) { PCMMDBFile manager = (PCMMDBFile)GetCoordHierarchy(); PCMask Mask; if (manager) { Mask = manager->GetSelMask ( selHnd ); if (Mask) return CheckMask ( Mask ); } return False; } Boolean CResidue::isNTerminus() { PPCResidue Res; int i,j,nRes; if (chain) { chain->GetResidueTable ( Res,nRes ); i = 0; j = -1; while ((i=0) return (Res[j]->index==index); } return False; } Boolean CResidue::isCTerminus() { PPCResidue Res; int i,j,nRes; if (chain) { chain->GetResidueTable ( Res,nRes ); i = nRes-1; j = -1; while ((i>=0) && (j<0)) { if (Res[i]) j = i; i--; } if (j>=0) return (Res[j]->index==index); } return False; } pstr CResidue::GetResidueID ( pstr ResidueID ) { ResidueID[0] = char(0); if (chain) { if (chain->model) sprintf ( ResidueID,"/%i/",chain->model->GetSerNum() ); else strcpy ( ResidueID,"/-/" ); strcat ( ResidueID,chain->chainID ); } else strcpy ( ResidueID,"/-/-" ); ParamStr ( ResidueID,pstr("/"),seqNum ); strcat ( ResidueID,"(" ); strcat ( ResidueID,name ); strcat ( ResidueID,")" ); if (insCode[0]) { strcat ( ResidueID,"." ); strcat ( ResidueID,insCode ); } return ResidueID; } int CResidue::CheckID ( int * snum, const InsCode inscode, const ResName resname ) { if (snum) { if (*snum!=seqNum) return 0; } if (inscode) { if ((inscode[0]!='*') && (strcmp(inscode,insCode))) return 0; } if (!resname) return 1; if ((resname[0]!='*') && (strcmp(resname,name))) return 0; return 1; } int CResidue::CheckIDS ( cpstr CID ) { ChainID chn; InsCode inscode; ResName resname; AtomName atm; Element elm; AltLoc aloc; pstr p1,p2; int mdl,sn,rc; rc = ParseAtomPath ( CID,mdl,chn,sn,inscode,resname, atm,elm,aloc,NULL ); // rc = ParseResID ( CID,sn,inscode,resname ); if (rc>=0) { p1 = NULL; p2 = NULL; if (inscode[0]!='*') p1 = inscode; if (resname[0]!='*') p2 = resname; if (!rc) return CheckID ( &sn ,p1,p2 ); else return CheckID ( NULL,p1,p2 ); } return 0; } // -------------------- Extracting atoms ------------------------- int CResidue::GetNumberOfAtoms() { return nAtoms; } int CResidue::GetNumberOfAtoms ( Boolean countTers ) { int i,na; na = 0; for (i=0;iTer)) na++; } return na; } PCAtom CResidue::GetAtom ( const AtomName aname, const Element elname, const AltLoc aloc ) { int i; for (i=0;iCheckID(aname,elname,aloc)) return atom[i]; } return NULL; } PCAtom CResidue::GetAtom ( int atomNo ) { if ((0<=atomNo) && (atomNo0) { atomTable = new PCAtom[nAtoms]; j = 0; for (i=0;iTer) atomTable[j++] = atom[i]; } NumberOfAtoms = j; } else { atomTable = NULL; NumberOfAtoms = 0; } } void CResidue::TrimAtomTable() { int i,j; j = 0; for (i=0;imodel) { A = chain->model->GetAllAtoms(); nA = chain->model->GetNumberOfAllAtoms(); } } k = 0; for (i=0;iCheckID(aname,elname,aloc)) { k++; kndex = atom[i]->index; if ((0model) { A = chain->model->GetAllAtoms(); nA = chain->model->GetNumberOfAllAtoms(); } } kndex = atom[atomNo]->index; if ((0model) { A = chain->model->GetAllAtoms(); nA = chain->model->GetNumberOfAllAtoms(); } } k = 0; for (i=0;iindex; if ((0model) { A = chain->model->GetAllAtoms(); nA = chain->model->GetNumberOfAllAtoms(); } } Exclude = False; n = 0; for (i=0;iTer) { occupancy = atom[i]->GetOccupancy(); strcpy ( aname,atom[i]->name ); strcpy ( aLoc ,atom[i]->altLoc ); i1 = -1; i2 = i; k = 0; for (j=i+1;jTer) && (!strcmp(atom[j]->name,aname))) { k++; occ = atom[j]->GetOccupancy(); if (occ>occupancy) { occupancy = occ; i1 = j; } if (aLoc[0]) { strcpy ( aL,atom[j]->altLoc ); if (!aL[0]) { aLoc[0] = char(0); i2 = j; } else if (strcmp(aL,aLoc)<0) { strcpy ( aLoc,aL ); i2 = j; } } } } if (k>0) { if (i1<0) { if (atom[i]->WhatIsSet & ASET_Occupancy) i1 = i; else i1 = i2; } for (j=i;jTer) && (!strcmp(atom[j]->name,aname))) { n++; kndex = atom[j]->index; if ((0Ter) atom[i]->Transform ( TMatrix ); } } // ----------------------------------------------------------------- void CResidue::MaskAtoms ( PCMask Mask ) { int i; for (i=0;iSetMask ( Mask ); } void CResidue::UnmaskAtoms ( PCMask Mask ) { int i; for (i=0;iRemoveMask ( Mask ); } // ------- user-defined data handlers int CResidue::PutUDData ( int UDDhandle, int iudd ) { if (UDDhandle & UDRF_RESIDUE) return CUDData::putUDData ( UDDhandle,iudd ); else return UDDATA_WrongUDRType; } int CResidue::PutUDData ( int UDDhandle, realtype rudd ) { if (UDDhandle & UDRF_RESIDUE) return CUDData::putUDData ( UDDhandle,rudd ); else return UDDATA_WrongUDRType; } int CResidue::PutUDData ( int UDDhandle, cpstr sudd ) { if (UDDhandle & UDRF_RESIDUE) return CUDData::putUDData ( UDDhandle,sudd ); else return UDDATA_WrongUDRType; } int CResidue::GetUDData ( int UDDhandle, int & iudd ) { if (UDDhandle & UDRF_RESIDUE) return CUDData::getUDData ( UDDhandle,iudd ); else return UDDATA_WrongUDRType; } int CResidue::GetUDData ( int UDDhandle, realtype & rudd ) { if (UDDhandle & UDRF_RESIDUE) return CUDData::getUDData ( UDDhandle,rudd ); else return UDDATA_WrongUDRType; } int CResidue::GetUDData ( int UDDhandle, pstr sudd, int maxLen ) { if (UDDhandle & UDRF_RESIDUE) return CUDData::getUDData ( UDDhandle,sudd,maxLen ); else return UDDATA_WrongUDRType; } int CResidue::GetUDData ( int UDDhandle, pstr & sudd ) { if (UDDhandle & UDRF_RESIDUE) return CUDData::getUDData ( UDDhandle,sudd ); else return UDDATA_WrongUDRType; } #define NOmaxdist2 12.25 Boolean CResidue::isMainchainHBond ( PCResidue res ) { // Test if there is main chain Hbond between PCRes1 (donor) and // PCRes2 (acceptor). // As defined Kabsch & Sanders // This probably needs the option of supporting alternative criteria PCAtom NAtom,OAtom,CAtom; realtype abx,aby,abz; realtype acx,acy,acz; realtype bcx,bcy,bcz; realtype absq,acsq,bcsq; NAtom = GetAtom ( "N" ); OAtom = res->GetAtom ( "O" ); CAtom = res->GetAtom ( "C" ); if (NAtom && OAtom && CAtom) { abx = OAtom->x - NAtom->x; aby = OAtom->y - NAtom->y; abz = OAtom->z - NAtom->z; absq = abx*abx + aby*aby + abz*abz; if (absq<=NOmaxdist2) { acx = NAtom->x - CAtom->x; acy = NAtom->y - CAtom->y; acz = NAtom->z - CAtom->z; bcx = CAtom->x - OAtom->x; bcy = CAtom->y - OAtom->y; bcz = CAtom->z - OAtom->z; acsq = acx*acx + acy*acy + acz*acz; bcsq = bcx*bcx + bcy*bcy + bcz*bcz; return (acos((bcsq+absq-acsq)/(2.0*sqrt(bcsq*absq)))>=Pi/2.0); } } return False; } void CResidue::write ( RCFile f ) { int i; byte Version=2; CUDData::write ( f ); f.WriteByte ( &Version ); f.WriteInt ( &seqNum ); f.WriteInt ( &label_seq_id ); f.WriteInt ( &label_entity_id ); f.WriteInt ( &index ); f.WriteInt ( &nAtoms ); f.WriteByte ( &SSE ); f.WriteTerLine ( name ,False ); f.WriteTerLine ( label_comp_id,False ); f.WriteTerLine ( label_asym_id,False ); f.WriteTerLine ( insCode ,False ); for (i=0;iindex) ); } void CResidue::read ( RCFile f ) { // IMPORTANT: array Atom in CMMDBFile class should be // read prior calling this function! PPCAtom A; int i,k; byte Version; FreeMemory (); CUDData::read ( f ); f.ReadByte ( &Version ); f.ReadInt ( &seqNum ); if (Version>1) { f.ReadInt ( &label_seq_id ); f.ReadInt ( &label_entity_id ); } f.ReadInt ( &index ); f.ReadInt ( &nAtoms ); f.ReadByte ( &SSE ); f.ReadTerLine ( name,False ); if (Version>1) { f.ReadTerLine ( label_comp_id,False ); f.ReadTerLine ( label_asym_id,False ); } f.ReadTerLine ( insCode,False ); AtmLen = nAtoms; A = NULL; if (chain) { if (chain->model) A = chain->model->GetAllAtoms(); } if ((nAtoms>0) && (A)) { atom = new PCAtom[nAtoms]; for (i=0;iSetResidue ( this ); atom[i]->_setBonds ( A ); } } else { for (i=0;i // ~~~~~~~~~ // **** Classes : CRandomNimber ( random number generator ) // ~~~~~~~~~ // // (C) E. Krissinel' 1997-2008 // // ================================================================= // #ifndef __MATH_H #include #endif #ifndef __Random_N__ #include "random_n.h" #endif // =================== CRandomNumber ========================== CRandomNumber::CRandomNumber ( long IJ, long KL ) { Init ( IJ,KL ); } void CRandomNumber::Init ( long IJ, long KL ) { long i,j,k,l,m, ii,jj; realtype s,t; iset = 0; gset = 0.0; if ((IJ<0) || (IJ>_RN_MAX_IJ) || (KL<0) || (KL>_RN_MAX_KL)) return; i = mod(IJ/177,177) + 2; j = mod(IJ,177) + 2; k = mod(KL/169,178) + 1; l = mod(KL,169); for (ii=0;ii<97;ii++) { s = 0.0; t = 0.5; for (jj=1;jj<=24;jj++) { m = mod(mod(i*j,179)*k,179); i = j; j = k; k = m; l = mod(53*l+1,169); if (mod(l*m,64)>=32) s += t; t *= 0.5; } U[ii] = s; } C = 362436.0 / 16777216.0; CD = 7654321.0 / 16777216.0; CM = 16777213.0 / 16777216.0; I97 = 96; J97 = 32; } // uniform [0..1] random number generator realtype CRandomNumber::random() { realtype uni; uni = U[I97] - U[J97]; if (uni<0.0) uni += 1.0; U[I97] = uni; I97--; if (I97<0) I97 = 96; J97--; if (J97<0) J97 = 96; C -= CD; if (C<0.0) C += CM; uni -= C; if (uni<0.0) uni += 1.0; return uni; } // uniform [-1..1] random number generator realtype CRandomNumber::srandom() { realtype uni; uni = U[I97] - U[J97]; if (uni<0.0) uni += 1.0; U[I97] = uni; I97--; if (I97<0) I97 = 96; J97--; if (J97<0) J97 = 96; C -= CD; if (C<0.0) C += CM; uni -= C; if (uni<0.0) uni += 1.0; return 2.0*uni - 1.0; } // gaussian random numbers realtype CRandomNumber::gauss_rnd() { realtype v1,v2,r,fac; if (iset==0) { do { v1 = srandom(); v2 = srandom(); r = v1*v1 + v2*v2; } while ((r>=1.0) || (r==0.0)); fac = sqrt(-2.0*log(r)/r); gset = v1*fac; iset = 1; return v2*fac; } else { iset = 0; return gset; } } void CRandomNumber::write ( RCFile f ) { int Version=1; f.WriteFile ( &Version,sizeof(Version) ); f.WriteFile ( &I97 ,sizeof(I97) ); f.WriteFile ( &J97 ,sizeof(J97) ); f.WriteFile ( U ,sizeof(U) ); f.WriteFile ( &C ,sizeof(C) ); f.WriteFile ( &CD ,sizeof(CD) ); f.WriteFile ( &CM ,sizeof(CM) ); f.WriteFile ( &gset ,sizeof(gset) ); f.WriteFile ( &iset ,sizeof(iset) ); } void CRandomNumber::read ( RCFile f ) { int Version; f.ReadFile ( &Version,sizeof(Version) ); f.ReadFile ( &I97 ,sizeof(I97) ); f.ReadFile ( &J97 ,sizeof(J97) ); f.ReadFile ( U ,sizeof(U) ); f.ReadFile ( &C ,sizeof(C) ); f.ReadFile ( &CD ,sizeof(CD) ); f.ReadFile ( &CM ,sizeof(CM) ); f.ReadFile ( &gset ,sizeof(gset) ); f.ReadFile ( &iset ,sizeof(iset) ); } /* static int m1 = 259200; static int ia1 = 7141; static int ic1 = 54773; static realtype rm1 = 1.0/259200.0; static int m2 = 134456; static int ia2 = 8121; static int ic2 = 28411; static realtype rm2 = 1.0/134456.0; static int m3 = 243000; static int ia3 = 4561; static int ic3 = 51349; static int ix1 = 0; static int ix2 = 0; static int ix3 = 0; static realtype R[97]; void randomize ( int iseed ) { int j; RndInit = True; ix1 = mod(ic1-iseed,m1); ix1 = mod(ia1*ix1+ic1,m1); ix2 = mod(ix1,m2); ix1 = mod(ia1*ix1+ic1,m1); ix3 = mod(ix1,m3); for (j=0;j<97;j++) { ix1 = mod(ia1*ix1+ic1,m1); ix2 = mod(ia2*ix2+ic2,m2); R[j] = (ix1+ix2*rm2)*rm1; } } realtype rand() { int j; realtype rnd; if (!RndInit) randomize(); ix1 = mod(ia1*ix1+ic1,m1); ix2 = mod(ia2*ix2+ic2,m2); ix3 = mod(ia3*ix3+ic3,m3); j = 1 + (97*ix3)/m3; j = IMax(j,1); j = IMin(j,97); rnd = R[j-1]; R[j] = (ix1+ix2*rm2)*rm1; return rnd; } */ // =========================================================== // End of Random_N mmdb-1.25.5/mmdb/mmdb_sbase.cpp0000775000175000017500000002433611736610510013200 00000000000000// $Id: mmdb_sbase.cpp,v 1.22 2012/01/26 17:52:21 ekr Exp $ // ================================================================= // // CCP4 Coordinate Library: support of coordinate-related // functionality in protein crystallography applications. // // Copyright (C) Eugene Krissinel 2000-2008. // // This library is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // // ================================================================= // // 21.02.06 <-- Date of Last Modification. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ----------------------------------------------------------------- // // **** Module : mmdb_sbase // ~~~~~~~~~ // **** Classes : CSBase ( structure base manager ) // ~~~~~~~~~ CSBAtom ( SB atom class ) // CSBBond ( SB bond class ) // CSBStructure ( SB structure (monomer) class ) // CSBIndex ( SB index class ) // // (C) E. Krissinel 2000-2008 // // ================================================================= // #ifndef __STDLIB_H #include #endif #ifndef __STRING_H #include #endif #ifndef __MMDB_SBase__ #include "mmdb_sbase.h" #endif // ========================= CSBase ============================= CSBase::CSBase() : CSBase0() { InitSBase(); } CSBase::~CSBase() { FreeMemory(); } void CSBase::InitSBase() { minDAdist = 2.0; maxDAdist = 3.9; // max distance for H-bonds maxSBdist = 4.0; // max distance for salt bridges maxHAdist2 = 2.5*2.5; maxDHAcos = 0.0; maxHAAcos = 0.0; maxDAAcos = 0.0; maxDDAcos = 0.0; } void CSBase::FreeMemory() { } void addAtomPair ( PCAtom a1, PCAtom a2, PSAtomPair & Pair, int & nPairs, int & nPAlloc ) { PSAtomPair AP; int i,i1,i2,j1,j2; Boolean Found; Found = False; i1 = a1->GetIndex(); i2 = a2->GetIndex(); for (i=0;(iGetIndex(); j2 = Pair[i].a2->GetIndex(); Found = (((i1==j1) && (i2==j2)) || ((i1==j2) && (i2==j1))); } if (!Found) { if (nPairs>=nPAlloc) { nPAlloc = nPairs+20; AP = new SAtomPair[nPAlloc]; for (i=0;i=nres1) return SBASE_EmptyResSet; MMDB = PCMMDBManager(Res1[i]->GetCoordHierarchy()); if (!MMDB) return SBASE_noCoordHierarchy; if (structFile) sFile = structFile; else sFile = GetStructFile(); if (!sFile) return SBASE_FileNotFound; selHandles1.getNewHandles ( MMDB ); for (i=0;iGetSelIndex ( selHandles1.selHndDonor,Donor1,nDonors1 ); MMDB->GetSelIndex ( selHandles2.selHndDonor,Donor2,nDonors2 ); if ((nDonors1<=0) && (nDonors2<=0)) { selHandles1.deleteSelections ( MMDB ); selHandles2.deleteSelections ( MMDB ); return SBASE_noDonors; } MMDB->GetSelIndex(selHandles1.selHndAcceptor,Acceptor1,nAcceptors1); MMDB->GetSelIndex(selHandles2.selHndAcceptor,Acceptor2,nAcceptors2); if ((nAcceptors1<=0) && (nAcceptors2<=0)) { selHandles1.deleteSelections ( MMDB ); selHandles2.deleteSelections ( MMDB ); return SBASE_noAcceptors; } if ((nDonors1*nAcceptors2<=0) && (nDonors2*nAcceptors1<=0)) { selHandles1.deleteSelections ( MMDB ); selHandles2.deleteSelections ( MMDB ); return SBASE_noHBonds; } // We now calculate contacts such that 1st contacting atom, either // acceptor or donor, belongs to 1st set of residues, and the second // one - to 2nd set of residues. Therefore we run SeekContacts on // two sets of donors and acceptors, identified by different group // id, merging the array of contacts for convenience. Contact = NULL; nContacts = 0; MMDB->SeekContacts ( Donor1,nDonors1,Acceptor2,nAcceptors2, minDAdist,RMax(maxDAdist,maxSBdist),0,Contact, nContacts,0,NULL,1,0 ); MMDB->SeekContacts ( Acceptor1,nAcceptors1,Donor2,nDonors2, minDAdist,RMax(maxDAdist,maxSBdist),0,Contact, nContacts,0,NULL,2,0 ); if (nContacts<=0) { selHandles1.deleteSelections ( MMDB ); selHandles2.deleteSelections ( MMDB ); return SBASE_noHBonds; } // 3. Check all contacts for h-bond geometry // merge all hydrogens into one selection as it is used // for checking with only MMDB->Select ( selHandles1.selHndHydrogen,STYPE_ATOM, selHandles2.selHndHydrogen,SKEY_OR ); for (i=0;iGetBonds ( DBond,nDBonds ); A->GetBonds ( ABond,nABonds ); if (nABonds>0) { // Check whether there are hydrogens bound to the donor, // and if they are then calculate h-bonds using them H = NULL; for (j=0;joccupancy>0.0) && DBond[j].atom->isInSelection( selHandles1.selHndHydrogen)) { H = DBond[j].atom; if ((H->GetDist2(A)GetCosine(D,A)<=maxDHAcos)) { // Check angles with all acceptor neighbours isHBond = True; for (k=0;(kGetCosine(H,ABond[k].atom)<=maxHAAcos); if (isHBond) { if (Contact[i].group<=1) addAtomPair ( H,A,HBond,nHBonds,nHBAlloc ); else addAtomPair ( A,H,HBond,nHBonds,nHBAlloc ); } } } if ((!H) && (nDBonds>0)) { // There were no hydrogens bonded to donor, assume that // the structure is incomplete and check donor-acceptor // geometry for possible h-bonding. isHBond = True; for (j=0;(jGetCosine(DBond[j].atom,A)<=maxDDAcos); for (j=0;(jGetCosine(D,ABond[j].atom)<=maxDAAcos); if (isHBond) { if (Contact[i].group<=1) addAtomPair ( D,A,HBond,nHBonds,nHBAlloc ); else addAtomPair ( A,D,HBond,nHBonds,nHBAlloc ); } } } } if ((Contact[i].dist<=maxSBdist) && (D->GetResidue()!=A->GetResidue()) && (!strcmp(D->element," N")) && (!strcmp(A->element," O"))) { // Check for salt bridge, which may be formed only by N-O // pairs of aminoacid atoms at distances less then maxSBdist if (!strcmp(D->name," N ")) { // mainchain nitrogen can form salt bridge only at N-terminus isSBridge = D->isNTerminus(); } else { // other nitrogens can form salt bridge only in LYS, ARG // and HIS resName = D->GetResName(); isSBridge = ((!strcmp(resName,"LYS")) || (!strcmp(resName,"ARG")) || (!strcmp(resName,"HIS"))); } if (isSBridge) { if ((!strcmp(A->name," O ")) || (!strcmp(A->name," OXT"))) { // mainchain oxygens can form salt bridge only at C-terminus isSBridge = A->isCTerminus(); } else { // other oxygens can form salt bridge only in GLU and ASP resName = A->GetResName(); isSBridge = ((!strcmp(resName,"GLU")) || (!strcmp(resName,"ASP"))); } if (isSBridge) { if (Contact[i].group<=1) addAtomPair ( D,A,SBridge,nSBridges,nSBAlloc ); else addAtomPair ( A,D,SBridge,nSBridges,nSBAlloc ); } } } } if (Contact) delete[] Contact; selHandles1.deleteSelections ( MMDB ); selHandles2.deleteSelections ( MMDB ); return SBASE_Ok; } mmdb-1.25.5/mmdb/mmdb_file.cpp0000775000175000017500000024574212145205351013026 00000000000000// $Id: mmdb_file.cpp,v 1.34 2012/01/26 17:52:20 ekr Exp $ // ================================================================= // // CCP4 Coordinate Library: support of coordinate-related // functionality in protein crystallography applications. // // Copyright (C) Eugene Krissinel 2000-2008. // // This library is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // // ================================================================= // // 16.05.13 <-- Date of Last Modification. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ----------------------------------------------------------------- // // **** Module : MMDB_File // ~~~~~~~~~ // **** Project : MacroMolecular Data Base (MMDB) // ~~~~~~~~~ // **** Classes : CMMDBFile ( macromolecular data file class ) // ~~~~~~~~~ // // (C) E. Krissinel 2000-2013 // // ================================================================= // #ifndef __STRING_H #include "string.h" #endif #ifndef __STDLIB_H #include "stdlib.h" #endif #ifndef __MMDB_File__ #include "mmdb_file.h" #endif #ifndef __MMDB_Atom__ #include "mmdb_atom.h" #endif #ifndef __MMDB_MMCIF__ #include "mmdb_mmcif.h" #endif #ifndef __MMDB_Defs__ #include "mmdb_defs.h" #endif #ifndef __MMDB_CIFDefs__ #include "mmdb_cifdefs.h" #endif #ifndef __MMDB_Tables__ #include "mmdb_tables.h" #endif // ===================== CMMDBFile ======================= CMMDBFile::CMMDBFile() : CUDData() { InitMMDBFile(); } CMMDBFile::CMMDBFile ( RPCStream Object ) : CUDData(Object) { InitMMDBFile(); } CMMDBFile::~CMMDBFile() { FreeFileMemory(); } void CMMDBFile::InitMMDBFile() { nModels = 0; Model = NULL; nAtoms = 0; AtmLen = 0; Atom = NULL; CIF = NULL; crModel = NULL; crChain = NULL; crRes = NULL; lcount = 0; strcpy ( S,"" ); // Flags = 0x00000000; // no special effects Flags = MMDBF_IgnoreElement; // done at request for default FType = MMDB_FILE_Undefined; // undefined file operation Exclude = True; ignoreRemarks = False; // used temporarily allowDuplChID = False; // used temporarily enforceUniqueChID = False; // used temporarily modelCnt = 0; // used only at reading files } void CMMDBFile::FreeCoordMemory() { //int i; /* // All atoms are kept in array Atom. Models, chains // and residues have only references to Atom and // they do not dispose Atoms when disposed themselves. // It is important, however, to dispose Atom at // still alive residues, because each atom wipes out // reference to itself from the corresponding residue // before it dies. if (Atom) { for (i=0;iConvertPDBString ( S ); if ((RC!=Error_WrongSection) && ignoreNonCoorPDBErrors) RC = 0; if (RC) break; } fend = f.FileEnd(); if (!fend) { ReadPDBLine ( f,S,sizeof(S) ); Title.TrimInput ( S ); lcount++; } } while (!fend); if (RC!=Error_WrongSection) return RC; // temporary solution: the rest of file is stored // in the form of strings while (!f.FileEnd() && strncmp(S,"CRYST" ,5) && strncmp(S,"ORIGX" ,5) && strncmp(S,"SCALE" ,5) && strncmp(S,"MTRIX" ,5) && strncmp(S,"TVECT" ,5) && strncmp(S,"MODEL ",6) && strncmp(S,"ATOM ",6) && strncmp(S,"SIGATM",6) && strncmp(S,"ANISOU",6) && strncmp(S,"SIGUIJ",6) && strncmp(S,"TER ",6) && strncmp(S,"HETATM",6) && strncmp(S,"ENDMDL",6)) { if (!strncmp(S,"LINK ",6)) crModel->ConvertPDBString ( S ); else if (!strncmp(S,"LINKR ",6)) crModel->ConvertPDBString ( S ); else if (!strncmp(S,"CISPEP",6)) { GetInteger ( modNum,&(S[43]),3 ); if (modNum<=0) modNum = 1; if (modNum!=1) SwitchModel ( modNum ); crModel->ConvertPDBString ( S ); if (modNum!=1) SwitchModel ( 1 ); } else { ContString = new CContString(S); SA.AddData ( ContString ); } ReadPDBLine ( f,S,sizeof(S) ); Title.TrimInput ( S ); lcount++; } // read crystallographic information section do { RC = Cryst.ConvertPDBString ( S ); if ((RC!=Error_WrongSection) && ignoreNonCoorPDBErrors) RC = 0; if (RC) break; fend = f.FileEnd(); if (!fend) { ReadPDBLine ( f,S,sizeof(S) ); Title.TrimInput ( S ); lcount++; } } while (!fend); if (!RC) { RC = Cryst.ConvertPDBString ( S ); if ((RC!=Error_WrongSection) && ignoreNonCoorPDBErrors) RC = Error_WrongSection; } Cryst.CalcCoordTransforms(); if (Flags & MMDBF_SimRWBROOK) Cryst.RWBROOKReadPrintout(); if (RC!=Error_WrongSection) return RC; // temporary solution: the rest of file is stored // in the form of strings while (!f.FileEnd() && strncmp(S,"MODEL ",6) && strncmp(S,"ATOM ",6) && strncmp(S,"SIGATM",6) && strncmp(S,"ANISOU",6) && strncmp(S,"SIGUIJ",6) && strncmp(S,"TER ",6) && strncmp(S,"HETATM",6) && strncmp(S,"ENDMDL",6)) { ContString = new CContString(S); SB.AddData ( ContString ); ReadPDBLine ( f,S,sizeof(S) ); Title.TrimInput ( S ); lcount++; } if (Flags & MMDBF_NoCoordRead) return 0; // read coordinate section RC = 0; do { RC = ReadPDBAtom ( S ); if (RC) break; fend = f.FileEnd(); if (!fend) { ReadPDBLine ( f,S,sizeof(S) ); Title.TrimInput ( S ); lcount++; } } while (!fend); // if (!RC) // RC = ReadPDBAtom(S); // commented on 28.05.2004, it appears that "CHAIN_ORDER" should not // be enforced here // cleanKey = PDBCLEAN_ATNAME | PDBCLEAN_CHAIN_ORDER; cleanKey = 0x00000000; if (Flags & MMDBF_EnforceAtomNames) cleanKey = PDBCLEAN_ATNAME; if (Flags & MMDBF_AutoSerials) cleanKey |= PDBCLEAN_SERIAL; if (cleanKey) PDBCleanup ( cleanKey ); if ((!f.FileEnd()) && (RC!=Error_WrongSection)) return RC; // temporary solution: the rest of file is stored // in the form of strings while (!f.FileEnd()) { if (strncmp(S,"END ",6)) { // END is added automatically ContString = new CContString(S); SC.AddData ( ContString ); } ReadPDBLine ( f,S,sizeof(S) ); Title.TrimInput ( S ); lcount++; } lcount--; // last line was not read return 0; } int CMMDBFile::ReadCIFASCII1 ( cpstr CIFLFName, byte gzipMode ) { pstr FName; FName = getenv ( CIFLFName ); if (FName) return ReadCIFASCII ( FName,gzipMode ); else return Error_NoLogicalName; } int CMMDBFile::ReadCIFASCII ( cpstr CIFFileName, byte gzipMode ) { CFile f; int rc; // open the file as ASCII for reading // opening it in pseudo-binary mode helps reading various // line terminators for files coming from different platforms f.assign ( CIFFileName,False,False,gzipMode ); if (f.reset(True)) { rc = ReadCIFASCII ( f ); f.shut(); } else rc = Error_CantOpenFile; return rc; } int CMMDBFile::ReadCIFASCII ( RCFile f ) { int W; // remove previous data ResetManager (); FreeFileMemory(); FType = MMDB_FILE_CIF; SetFlag ( 0 ); CIFErrorLocation[0] = char(0); // CIF reading phase lcount = 0; // line counter S[0] = char(0); if (f.FileEnd()) return Error_EmptyFile; if (!CIF) CIF = new CMMCIFData(); CIF->SetStopOnWarning ( True ); CIF->SetPrintWarnings ( (Flags & MMDBF_PrintCIFWarnings)!=0 ); W = CIF->ReadMMCIFData ( f,S,lcount ); if (W) { if (W==CIFRC_NoDataLine) return Error_NotACIFFile; if (W & CIFW_UnrecognizedItems) return Error_UnrecognCIFItems; if (W & CIFW_MissingField) return Error_MissingCIFField; if (W & CIFW_EmptyLoop) return Error_EmptyCIFLoop; if (W & CIFW_UnexpectedEOF) return Error_UnexpEndOfCIF; if (W & CIFW_LoopFieldMissing) return Error_MissgCIFLoopField; if (W & CIFW_NotAStructure) return Error_NotACIFStructure; if (W & CIFW_NotALoop) return Error_NotACIFLoop; return int(W); } W = ReadFromCIF ( CIF ); if (CIF) { delete CIF; CIF = NULL; } return W; } int CMMDBFile::ReadFromCIF ( PCMMCIFData CIFD ) { PCMMCIFLoop Loop1,Loop2; pstr F,FC; word cleanKey; int RC,i,l,j,n,retc; RC = Title.GetCIF ( CIFD ); if (RC) { CIFD->Optimize(); return RC; } SwitchModel ( 1 ); if (!crModel) return Error_GeneralError1; RC = crModel->GetCIF ( CIFD ); if (RC) { CIFD->Optimize(); return RC; } RC = Cryst.GetCIF ( CIFD ); if (RC) { CIFD->Optimize(); return RC; } Cryst.CalcCoordTransforms(); if (Flags & MMDBF_SimRWBROOK) Cryst.RWBROOKReadPrintout(); RC = ReadCIFAtom ( CIFD ); Loop1 = CIFD->GetLoop ( CIFCAT_ENTITY ); Loop2 = CIFD->GetLoop ( CIFCAT_STRUCT_ASYM ); if (Loop1 && Loop2) { // make 'Het' atoms l = Loop1->GetLoopLength(); n = Loop2->GetLoopLength(); for (i=0;iGetString ( CIFTAG_TYPE,i,retc ); if (F && (!retc)) { if (!strcasecmp(F,"non-polymer")) { F = Loop1->GetString ( CIFTAG_ID,i,retc ); if (F && (!retc)) for (j=0;jGetString ( CIFTAG_ENTITY_ID,j,retc ); if (FC && (!retc)) { if (!strcasecmp(FC,F)) { FC = Loop2->GetString ( CIFTAG_ID,j,retc ); if (FC && (!retc)) MakeHetAtoms ( FC,True ); } } } } } } } if (!RC) { // deleting these CIF loops here is a temporary solution // taken in order to avoid mess at rewriting the CIF file. CIFD->DeleteLoop ( CIFCAT_ATOM_SITE ); CIFD->DeleteLoop ( CIFCAT_ATOM_SITE_ANISOTROP ); CIFD->Optimize (); } cleanKey = 0x00000000; if (Flags & MMDBF_EnforceAtomNames) cleanKey = PDBCLEAN_ATNAME; if (Flags & MMDBF_AutoSerials) cleanKey |= PDBCLEAN_SERIAL; if (cleanKey) PDBCleanup ( cleanKey ); return RC; } int CMMDBFile::ReadCoorFile1 ( cpstr LFName, byte gzipMode ) { pstr FName; FName = getenv ( LFName ); if (FName) return ReadCoorFile ( FName,gzipMode ); else return Error_NoLogicalName; } int CMMDBFile::ReadCoorFile ( cpstr CFName, byte gzipMode ) { // auto format recognition int kin; Boolean IBL; kin = isMMDBBIN ( CFName,gzipMode ); if (kin==Error_EmptyFile) return Error_EmptyFile; if (kin<0) return Error_CantOpenFile; if (kin==0) return ReadMMDBF ( CFName,gzipMode ); IBL = ((Flags & MMDBF_IgnoreBlankLines)!=0); if (isPDB(CFName,gzipMode,IBL)==0) return ReadPDBASCII ( CFName,gzipMode ); if (isCIF(CFName,gzipMode)==0) return ReadCIFASCII ( CFName,gzipMode ); return Error_ForeignFile; } int CMMDBFile::ReadCoorFile ( RCFile f ) { // auto format recognition int kin; Boolean IBL; kin = isMMDBBIN ( f ); f.reset ( True ); if (kin==Error_EmptyFile) return Error_EmptyFile; if (kin<0) return Error_CantOpenFile; if (kin==0) return ReadMMDBF ( f ); IBL = ((Flags & MMDBF_IgnoreBlankLines)!=0); kin = isPDB ( f,IBL ); f.reset ( True ); if (kin==0) return ReadPDBASCII ( f ); kin = isCIF ( f ); f.reset ( True ); if (kin==0) return ReadCIFASCII ( f ); return Error_ForeignFile; } word CMMDBFile::PDBCleanup ( word CleanKey ) { // cleans coordinate part to comply with PDB standards: // // CleanKey Action // PDBCLEAN_ATNAME pads atom names with spaces to form 4-symbol names // PDBCLEAN_TER inserts TER cards in the end of each chain // PDBCLEAN_CHAIN generates 1-character chain ids instead of // those many-character // PDBCLEAN_CHAIN_STRONG generates 1-character chain ids starting // from 'A' on for all ids, including single-char // PDBCLEAN_ALTCODE generates 1-character alternative codes instead // of those many-character // PDBCLEAN_ALTCODE_STRONG generates 1-character alternative codes // from 'A' on for all codes, including // single-character ones // PDBCLEAN_SERIAL puts serial numbers in due order // PDBCLEAN_INDEX reorders the internal index of atoms such that // it follows the actual order of atoms in // the object hierarchy // PDBCLEAN_SEQNUM renumbers all residues so that they go // incrementally-by-one without insertion codes // PDBCLEAN_CHAIN_ORDER puts chains in order of atom's serial numbers // PDBCLEAN_SOLVENT moves solvent chains at the end of each model // PDBCLEAN_ELEMENT calculates PDB element names where they are not // found in the chemical element table // PDBCLEAN_ELEMENT_STRONG calculates all chemical element names // // Return codes (as bits): // 0 Ok // PDBCLEAN_CHAIN too many chains for assigning them 1-letter codes // PDBCLEAN_ATNAME element names were not available // PDBCLEAN_ALTCODE too many alternative codes encountered. // word RC; int i,j,k,nal,nch,nr, nch1,nch2; char c; AltLoc * altLoc; ChainID * chain_ID; char aLoc [257]; char chnID[257]; int model,modl; PPCAtom Atom1; PPCChain Chain1,Chain2; PCModel crModel0; PCChain crChain0; PCResidue crRes0; PCAtom atom; pstr chID; ChainID chainID; Boolean NewChain,Done,Solvent; RC = 0; if (nAtoms<=0) return RC; if (CleanKey & PDBCLEAN_ATNAME) for (i=0;iMakePDBAtomName()) RC |= PDBCLEAN_ATNAME; k = -1; if (CleanKey & PDBCLEAN_TER) { model = -1; crModel0 = crModel; for (i=0;iGetModelNum(); chID = Atom[i]->GetChainID (); if (model<0) { model = modl; SwitchModel ( model ); if (chID) strcpy ( chainID,chID ); else chainID[0] = char(0); } else { if (model!=modl) NewChain = True; else if (chID) NewChain = strcmp(chID,chainID)!=0; else NewChain = chainID[0]!=char(0); if (NewChain) { if (k>=0) { if ((!Atom[k]->Ter) && (!Atom[k]->Het)) { // insert 'Ter' before atom in position 'i' PutAtom ( -(i+1),Atom[k]->serNum+1,pstr("TER"), Atom[k]->GetResName(),Atom[k]->GetChainID(), Atom[k]->GetSeqNum (),Atom[k]->GetInsCode(), pstr(" "),pstr(" "),pstr(" ") ); Atom[i]->MakeTer(); } } model = modl; SwitchModel ( model ); if (chID) strcpy ( chainID,chID ); else chainID[0] = char(0); } } k = i; } if (k>=0) { if ((!Atom[k]->Ter) && (!Atom[k]->Het)) { // add last TER i = nAtoms; SwitchModel ( Atom[k]->GetModelNum() ); PutAtom ( 0,nAtoms+1,pstr("TER"),Atom[k]->GetResName(), Atom[k]->GetChainID(),Atom[k]->GetSeqNum(), Atom[k]->GetInsCode(),pstr(" "),pstr(" "), pstr(" ") ); Atom[i]->MakeTer(); } } crModel = crModel0; } if (CleanKey & (PDBCLEAN_CHAIN | PDBCLEAN_CHAIN_STRONG)) { chain_ID = new ChainID[256]; for (i=0;inChains;j++) { crChain0 = Model[i]->Chain[j]; if (crChain0) { if (!crChain0->chainID[0]) strcpy ( crChain0->chainID," " ); k = 0; while ((kchainID))) k++; if (k>=nch) { if (nch>=255) RC |= PDBCLEAN_CHAIN; else { strcpy ( chain_ID[nch],crChain0->chainID ); if (!chain_ID[nch][1]) chnID[nch] = chain_ID[nch][0]; nch++; } } } } c = 'A'; if (CleanKey & PDBCLEAN_CHAIN_STRONG) { // rename all chains through from A to Z for (k=0;knChains;j++) { crChain0 = Model[i]->Chain[j]; if (crChain0) { k = 0; while ((kchainID))) k++; strcpy ( crChain0->prevChainID,crChain0->chainID ); crChain0->chainID[0] = chnID[k]; crChain0->chainID[1] = char(0); } } } delete[] chain_ID; } if (CleanKey & (PDBCLEAN_ALTCODE | PDBCLEAN_ALTCODE_STRONG)) { altLoc = new AltLoc[256]; for (i=0;i<256;i++) { strcpy ( altLoc[i]," " ); aLoc[i] = char(0); } aLoc[0] = ' '; aLoc[256] = char(0); nal = 1; for (i=0;ialtLoc[0]) strcpy ( Atom[i]->altLoc," " ); else { k = 0; while ((kaltLoc))) k++; if (k>=nal) { if (nal>=255) RC |= PDBCLEAN_ALTCODE; else { strcpy ( altLoc[nal],Atom[i]->altLoc ); if (!altLoc[nal][1]) aLoc[nal] = altLoc[nal][0]; nal++; } } } } c = 'A'; if (CleanKey & PDBCLEAN_ALTCODE_STRONG) for (i=1;ialtLoc))) k++; Atom[i]->altLoc[0] = aLoc[k]; Atom[i]->altLoc[1] = char(0); } delete[] altLoc; } if (CleanKey & PDBCLEAN_SEQNUM) for (i=0;inChains;j++) { crChain0 = crModel0->Chain[j]; if (crChain0) { nr = 0; for (k=0;knResidues;k++) { crRes0 = crChain0->Residue[k]; if (crRes0) { nr++; crRes0->seqNum = nr; crRes0->insCode[0] = char(0); } } } } } if (CleanKey & PDBCLEAN_SOLVENT) { Atom1 = new PCAtom[nAtoms]; k = 1; for (i=0;inChains>k) k = Model[i]->nChains; } Chain1 = new PCChain[k]; Chain2 = new PCChain[k]; k = 0; for (i=0;inChains;nch++) { crChain0 = crModel0->Chain[nch]; if (crChain0) { Solvent = False; for (nr=0;(nrnResidues) && (!Solvent);nr++) { crRes0 = crChain0->Residue[nr]; if (crRes0) for (j=0;(jname ); } if (Solvent) Chain2[nch2++] = crChain0; else Chain1[nch1++] = crChain0; } } for (nch=0;nchnResidues;nr++) { crRes0 = crChain0->Residue[nr]; if (crRes0) for (j=0;jnAtoms;j++) if (crRes0->atom[j]) { Atom1[k] = crRes0->atom[j]; Atom1[k]->index = k+1; k++; } } crModel0->Chain[nch] = Chain1[nch]; } for (nch=0;nchnResidues;nr++) { crRes0 = crChain0->Residue[nr]; if (crRes0) for (j=0;jnAtoms;j++) if (crRes0->atom[j]) { Atom1[k] = crRes0->atom[j]; Atom1[k]->index = k+1; k++; } } crModel0->Chain[nch1++] = Chain2[nch]; } crModel0->nChains = nch1; } } delete[] Chain1; delete[] Chain2; if (Atom) delete[] Atom; Atom = Atom1; AtmLen = nAtoms; nAtoms = k; } if (CleanKey & (PDBCLEAN_CHAIN_ORDER | PDBCLEAN_CHAIN_ORDER_IX)) { for (i=0;inChains;j++) { crChain0 = crModel0->Chain[j]; if (crChain0) { crChain0->nWeights = 0; crChain0->Weight = 0.0; if (kChain[k] = crModel0->Chain[j]; crModel0->Chain[j] = NULL; } k++; } } crModel0->nChains = k; } } if (CleanKey & PDBCLEAN_CHAIN_ORDER) for (i=0;iGetChain(); crChain0->nWeights++; crChain0->Weight += Atom[i]->serNum; } else for (i=0;iGetChain(); crChain0->nWeights++; crChain0->Weight += Atom[i]->GetIndex(); } for (i=0;inChains;j++) { crChain0 = crModel0->Chain[j]; if (crChain0->nWeights) crChain0->Weight /= crChain0->nWeights; } // bubble sorting do { Done = True; for (j=1;jnChains;j++) if (crModel0->Chain[j-1]->Weight > crModel0->Chain[j]->Weight) { crChain0 = crModel0->Chain[j-1]; crModel0->Chain[j-1] = crModel0->Chain[j]; crModel0->Chain[j] = crChain0; Done = False; } } while (!Done); } } } if (CleanKey & PDBCLEAN_INDEX) { k = 0; for (i=0;inChains;nch++) { crChain0 = crModel0->Chain[nch]; if (crChain0) { for (nr=0;nrnResidues;nr++) { crRes0 = crChain0->Residue[nr]; if (crRes0) { for (j=0;jnAtoms;j++) { atom = crRes0->atom[j]; if (atom) { Atom[atom->index-1] = Atom[k]; if (Atom[k]) Atom[k]->index = atom->index; Atom[k] = atom; k++; atom->index = k; } } } } } } } } nAtoms = k; } if (CleanKey & PDBCLEAN_SERIAL) { k = 0; for (i=0;iindex = k+1; Atom[k]->serNum = Atom[k]->index; k++; } nAtoms = k; } if (CleanKey & PDBCLEAN_ELEMENT) { for (i=0;iTer)) { if (getElementNo(Atom[i]->element)==ELEMENT_UNKNOWN) { strcpy ( Atom[i]->element," " ); Atom[i]->MakePDBAtomName(); } } } if (CleanKey & PDBCLEAN_ELEMENT_STRONG) { for (i=0;iTer)) { strcpy ( Atom[i]->element," " ); Atom[i]->MakePDBAtomName(); } } return RC; } void CMMDBFile::MakeHetAtoms ( cpstr chainID, Boolean Make ) { // Makes all atoms in chain 'chainID', in all models, as 'Het' atoms // if Make is set True, and makes them 'ordinary' atoms otherwise. // 'Ter' is automatically removed when converting to 'Het' atoms, // and is automatically added when converting to 'ordinary' atoms. int i,j,k,l,n; PCModel crModel0; PCChain crChain0; PCResidue crRes0; crModel0 = crModel; for (i=0;inChains;j++) { crChain0 = Model[i]->Chain[j]; if (crChain0) { if (!strcmp(crChain0->chainID,chainID)) { n = 0; for (k=0;knResidues;k++) { crRes0 = crChain0->Residue[k]; if (crRes0) for (l=0;lnAtoms;l++) if (crRes0->atom[l]) { crRes0->atom[l]->Het = Make; n = crRes0->atom[l]->index; } } if (n>0) { n--; if (Atom[n]->Het && Atom[n]->Ter) RemoveAtom ( n+1 ); else if ((!Atom[n]->Het) && (!Atom[n]->Ter)) { SwitchModel ( Model[i]->GetSerNum() ); if (nserNum+1,pstr("TER"), Atom[n]->GetResName(),Atom[n]->GetChainID(), Atom[n]->GetSeqNum (),Atom[n]->GetInsCode(), pstr(" "),pstr(" "),pstr(" ") ); else PutAtom ( 0,nAtoms+1,pstr("TER"), Atom[n]->GetResName(),Atom[n]->GetChainID(), Atom[n]->GetSeqNum (),Atom[n]->GetInsCode(), pstr(" "),pstr(" "),pstr(" ") ); Atom[n+1]->MakeTer(); } } } } } crModel = crModel0; } void CMMDBFile::RemoveAtom ( int index ) { // Removes atom at the specified index in the Atom array. // This index is always accessible as Atom[index]->index. // If this leaves a residue empty, the residue is removed. // If this leaves an empty chain, the chain is removed as well; // the same happens to the model. PCResidue crRes0; PCChain crChain0; PCModel crModel0; int i,j; if ((index>0) && (index<=nAtoms)) { if (Atom[index-1]) { crRes0 = Atom[index-1]->residue; if (crRes0) { if (crRes0->_ExcludeAtom(index)) { // the residue appears empty after the exclusion if (crRes) { if ((crRes->seqNum==crRes0->seqNum) && (!strcmp(crRes->insCode,crRes0->insCode))) crRes = NULL; } crChain0 = crRes0->chain; if (crChain0) { if (crChain0->_ExcludeResidue(crRes0->name,crRes0->seqNum, crRes0->insCode)) { // the chain appears empty after the exclusion if (crChain) { if (!strcmp(crChain->chainID,crChain0->chainID)) crChain = NULL; } crModel0 = PCModel(crChain0->model); if (crModel0) { if (crModel0->_ExcludeChain(crChain0->chainID)) { // the model appears ampty after the exclusion if (crModel) { if (crModel->serNum==crModel0->serNum) crModel = NULL; } i = crModel0->serNum-1; delete Model[i]; Model[i] = NULL; } } delete crChain0; // it is already excluded from the hierarchy! } } delete crRes0; // it is already excluded from the hierarchy! } } delete Atom[index-1]; // it is already excluded from the hierarchy! Atom[index-1] = NULL; // now rearrange and re-index atoms. j = 0; for (i=0;iindex = j+1; j++; } nAtoms = j; } } } int CMMDBFile::_ExcludeModel ( int serNum ) { // _ExcludeModel(..) excludes (but does not dispose!) a model // from the file. Returns 1 if the file gets empty and 0 otherwise. int i,k; if (!Exclude) return 0; if ((0serNum = k+1; k++; } nModels = k; if (nModels<=0) return 1; else return 0; } int CMMDBFile::FinishStructEdit() { // Makes a new atom index after insertion or deletion of atoms. // This function may change atoms' positions in the index and // correspondingly the CAtom::index field. PCResidue res; PCChain chain; PCModel model; PPCAtom Atom1; int i,j,k,l,n,index,nAtoms1; // calculate new number of atoms nAtoms1 = 0; for (i=0;inChains;j++) { chain = model->Chain[j]; if (chain) { for (k=0;knResidues;k++) { res = chain->Residue[k]; if (res) { res->TrimAtomTable(); nAtoms1 += res->nAtoms; } } chain->TrimResidueTable(); } } model->TrimChainTable(); } } TrimModelTable(); // compile a new index and null the old one if (nAtoms1>0) Atom1 = new PCAtom[nAtoms1]; else Atom1 = NULL; n = 0; for (i=0;inChains;j++) { chain = model->Chain[j]; for (k=0;knResidues;k++) { res = chain->Residue[k]; for (l=0;lnAtoms;l++) { Atom1[n] = res->atom[l]; index = Atom1[n]->index; if ((index>0) && (index<=AtmLen)) Atom[index-1] = NULL; Atom1[n]->index = n+1; n++; } } } } // if (n!=nAtoms1) { // printf ( " **** PROGRAM ERROR IN CMMDBFile::FinishStructEdit\n" ); // exit ( 1 ); // } // check if there are dead atoms in the old index for (i=0;iserNum = j+1; j++; } nModels = j; } int CMMDBFile::GenerateNCSMates() { // // Generates NCS mates according to NCS matrices given // in Cryst. This will result in generating many-character // chain names, composed as 'x_n' where 'x' is the original // name and 'n' is a unique number, which will coincide with // the symmetry operation (order) number. Another side // effect will be a disorder in atoms' serial numbers. // The hierarchy should therefore be cleaned after // generating the NCS mates. An appropriate way to do that // is to issue the following call: // // PDBCleanup ( PDBCLEAN_TER | PDBCLEAN_ALTCODE_STRONG | // PDBCLEAN_CHAIN_STRONG | PDBCLEAN_SERIAL ); // PPCChain chainTable,chain; PCChain chn; mat44 ncs_m; ChainID chainID; int i,j,k,nNCSOps,nChains,iGiven; nNCSOps = Cryst.GetNumberOfNCSMatrices(); if (nNCSOps<=0) return 1; for (i=0;iGetChainTable ( chainTable,nChains ); if (nChains>0) { chain = new PCChain[nChains]; for (j=0;jCopy ( chain[j] ); sprintf ( chainID,"%s_%i", chain[j]->GetChainID(),k+1 ); chn->SetChainID ( chainID ); chn->ApplyTransform ( ncs_m ); Model[i]->AddChain ( chn ); } } } delete[] chain; } } return 0; } void CMMDBFile::ApplyNCSTransform ( int NCSMatrixNo ) { mat33 t; vect3 v; int i; if (!Cryst.GetNCSMatrix(NCSMatrixNo,t,v)) return; for (i=0;iTransform ( t,v ); } int CMMDBFile::PutPDBString ( cpstr PDBString ) { int RC; PCContString ContString; strcpy ( S,PDBString ); // maintain the buffer! PadSpaces ( S,80 ); lcount++; // belongs to title? RC = Title.ConvertPDBString ( S ); if (RC!=Error_WrongSection) return RC; // belongs to primary structure section? SwitchModel ( 1 ); RC = crModel->ConvertPDBString ( S ); if (RC!=Error_WrongSection) return RC; // belongs to the crystallographic information section? RC = Cryst.ConvertPDBString ( S ); if (RC!=Error_WrongSection) { // if (RC==0) Cryst.CalcCoordTransforms(); return RC; } // belongs to the coordinate section? RC = ReadPDBAtom ( S ); if (RC!=Error_WrongSection) return RC; // temporary solution: the rest of file is stored // in the form of strings if ((S[0]) && (S[0]!=' ') && (strncmp(S,"END ",6))) { // END is added automatically ContString = new CContString(S); SC.AddData ( ContString ); } return 0; } int CMMDBFile::AddPDBASCII1 ( cpstr PDBLFName, byte gzipMode ) { pstr FName; FName = getenv ( PDBLFName ); if (FName) return AddPDBASCII ( FName,gzipMode ); else return Error_NoLogicalName; } int CMMDBFile::AddPDBASCII ( cpstr PDBFileName, byte gzipMode ) { int RC; CFile f; // open the file as ASCII for reading // opening it in pseudo-binary mode helps reading various // line terminators for files coming from different platforms f.assign ( PDBFileName,False,False,gzipMode ); if (f.reset(True)) { lcount = 1; // line counter RC = 0; while ((!f.FileEnd()) && (!RC)) { ReadPDBLine ( f,S,sizeof(S) ); RC = PutPDBString ( S ); } f.shut(); } else RC = Error_CantOpenFile; return RC; } void CMMDBFile::GetInputBuffer ( pstr Line, int & count ) { if (FType==MMDB_FILE_PDB) { // PDB File strcpy ( Line,S ); count = lcount; } else if (FType==MMDB_FILE_CIF) { if (!CIFErrorLocation[0]) { // CIF reading phase strcpy ( Line,S ); count = lcount; } else { strcpy ( Line,CIFErrorLocation ); count = -1; // CIF interpretation phase } } else { Line[0] = char(0); count = -2; } } int CMMDBFile::CrystReady() { // Returns flags: // CRRDY_Complete if crystallographic information is complete // CRRDY_NotPrecise if cryst. inf-n is not precise // CRRDY_isTranslation if cryst. inf-n contains translation // CRRDY_NoOrthCode no orthogonalization code // Fatal: // CRRDY_NoTransfMatrices if transform. matrices were not calculated // CRRDY_Unchecked if cryst. inf-n was not checked // CRRDY_Ambiguous if cryst. inf-n is ambiguous // CRRDY_NoCell if cryst. inf-n is unusable // CRRDY_NoSpaceGroup if space group is not set int k; if (!(Cryst.WhatIsSet & CSET_Transforms)) return CRRDY_NoTransfMatrices; if ((Cryst.WhatIsSet & CSET_CellParams)!=CSET_CellParams) return CRRDY_NoCell; if (!(Cryst.WhatIsSet & CSET_SpaceGroup)) return CRRDY_NoSpaceGroup; if (Cryst.CellCheck & CCHK_Unchecked) return CRRDY_Unchecked; if (Cryst.CellCheck & CCHK_Disagreement) return CRRDY_Ambiguous; k = 0x0000; if (Cryst.CellCheck & CCHK_Error) k |= CRRDY_NotPrecise; if (Cryst.CellCheck & CCHK_Translations) k |= CRRDY_isTranslation; if (Cryst.CellCheck & CCHK_NoOrthCode) k |= CRRDY_NoOrthCode; return k; } Boolean CMMDBFile::isCrystInfo() { return (((Cryst.WhatIsSet & CSET_CellParams)==CSET_CellParams) && (Cryst.WhatIsSet & CSET_SpaceGroup)); } Boolean CMMDBFile::isCellInfo() { return ((Cryst.WhatIsSet & CSET_CellParams)==CSET_CellParams); } Boolean CMMDBFile::isSpaceGroup() { return (Cryst.WhatIsSet & CSET_SpaceGroup); } Boolean CMMDBFile::isTransfMatrix() { return Cryst.areMatrices(); } Boolean CMMDBFile::isScaleMatrix() { return ((Cryst.WhatIsSet & CSET_ScaleMatrix)==CSET_ScaleMatrix); } Boolean CMMDBFile::isNCSMatrix() { return Cryst.isNCSMatrix(); } int CMMDBFile::AddNCSMatrix ( mat33 & ncs_m, vect3 & ncs_v, int iGiven ) { return Cryst.AddNCSMatrix ( ncs_m,ncs_v,iGiven ); } int CMMDBFile::GetNumberOfNCSMatrices() { return Cryst.GetNumberOfNCSMatrices(); } int CMMDBFile::GetNumberOfNCSMates() { // Returns the number of NCS mates not given in the file (iGiven==0) return Cryst.GetNumberOfNCSMates(); } Boolean CMMDBFile::GetNCSMatrix ( int NCSMatrixNo, // 0..N-1 mat44 & ncs_m, int & iGiven ) { return Cryst.GetNCSMatrix ( NCSMatrixNo,ncs_m,iGiven ); } int CMMDBFile::ReadPDBAtom ( cpstr L ) { // If string L belongs to the coordinate section // (records ATOM, SIGATM, ANISOU, SIGUIJ, TER, HETATM), // the correspondent information is retrieved and // stored in the dynamic Atom array. In parallel, the // structures of Model/Chain/Residue are generated and // referenced to the corresponding Atom. // If processing of L was successful, the return is 0, // otherwise it returns the corresponding Error_XXX // code. // If L does not belong to the coordinate section, // Error_WrongSection is returned. int RC,index,i; if (!strncmp(L,"ATOM ",6)) { index = nAtoms+1; // index for the next atom in Atom array RC = CheckAtomPlace ( index,L ); if (!RC) RC = Atom[index-1]->ConvertPDBATOM ( index,L ); } else if (!strncmp(L,"SIGATM",6)) { index = nAtoms; // keep index! RC = CheckAtomPlace ( index,L ); if (!RC) RC = Atom[index-1]->ConvertPDBSIGATM ( index,L ); } else if (!strncmp(L,"ANISOU",6)) { index = nAtoms; // keep index RC = CheckAtomPlace ( index,L ); if (!RC) RC = Atom[index-1]->ConvertPDBANISOU ( index,L ); } else if (!strncmp(L,"SIGUIJ",6)) { index = nAtoms; // keep index RC = CheckAtomPlace ( index,L ); if (!RC) RC = Atom[index-1]->ConvertPDBSIGUIJ ( index,L ); } else if (!strncmp(L,"TER ",6)) { index = nAtoms+1; // new place in Atom array RC = CheckAtomPlace ( index,L ); if (!RC) RC = Atom[index-1]->ConvertPDBTER ( index,L ); } else if (!strncmp(L,"HETATM",6)) { index = nAtoms+1; // new place in Atom array RC = CheckAtomPlace ( index,L ); if (!RC) RC = Atom[index-1]->ConvertPDBHETATM ( index,L ); } else if (!strncmp(L,"MODEL ",6)) { modelCnt++; RC = SwitchModel ( L ); for (i=0;(iserNum==Model[i]->serNum) RC = Error_DuplicatedModel; } // if (!RC) { // if (crModel->serNum!=modelCnt) // RC = Error_DuplicatedModel; // } } else if (!strncmp(L,"ENDMDL",6)) { crModel = NULL; crChain = NULL; crRes = NULL; RC = 0; } else return Error_WrongSection; return RC; } int CMMDBFile::ReadCIFAtom ( PCMMCIFData CIFD ) { PCMMCIFLoop Loop,LoopAnis; int RC,i,index,nATS; Loop = CIFD->GetLoop ( CIFCAT_ATOM_SITE ); if (!Loop) return 0; // no atom coordinates in the file LoopAnis = CIFD->GetLoop ( CIFCAT_ATOM_SITE_ANISOTROP ); nATS = Loop->GetLoopLength(); for (i=1;i<=nATS;i++) { // nAtoms and i should always coincide at this point. This piece // of code was however left in order to reach identity with // ReadPDBAtom(..). index = nAtoms+1; // index for the next atom in Atom array RC = CheckAtomPlace ( index,Loop ); if (!RC) RC = Atom[index-1]->GetCIF ( i,Loop,LoopAnis ); if (RC && (RC!=Error_CIF_EmptyRow)) return RC; } if (Flags & MMDBF_AutoSerials) PDBCleanup ( PDBCLEAN_SERIAL ); return 0; } int CMMDBFile::PutAtom ( int index, int serNum, const AtomName atomName, const ResName resName, const ChainID chainID, int seqNum, const InsCode insCode, const AltLoc altLoc, const SegID segID, const Element element ) { // An atom with the specified properties is put into the // structure. The current model is used; if no model is // set (crModel==NULL), one is created. Coordinates and // other parameters of the atom need to be set separately. // // If index is positive and there is already an atom at // this position in the system, the new atom will REPLACE // it. The corresponding residues are automatically // updated. // // If index is null (=0), the new atom will be put on // the top of the structure, i.e. it will be put into // (index=nAtoms+1)-th position. // // If index is negative, then the new atom is INSERTED // BEFORE the atom in the (-index)th position. For // saving the computational efforts, this WILL NOT cause // the recalculation of all atoms' serial numbers // according to their actual positions. It will be needed // however to put the things in order by calling // CMMDBFile::OrderAtoms() at a certain point, especially // before writing an output ASCII file. NOTE that this // ordering is never done automatically. // // Limitation: if PutAtom implies creating new // chains/residues, these are always created on the top // of existing chains/residues. int i,kndex,RC; kndex = index; if (kndex<0) { // the new atom is to be inserted kndex = -kndex; if (kndex>AtmLen) ExpandAtomArray ( kndex+1000-AtmLen ); if (Atom[kndex-1]!=NULL) { // the position is occupied // expand the array if necessary if (nAtoms>=AtmLen) ExpandAtomArray ( IMax(kndex,nAtoms)+1000-AtmLen ); // now shift all atoms from (kndex-1)th to the end of array. // note that this does not affect residues as they keep only // pointers on atoms for (i=nAtoms;i>=kndex;i--) { Atom[i] = Atom[i-1]; Atom[i]->index = i+1; // this is Ok because residues keep // POINTERS rather than indices! } Atom[kndex-1] = NULL; nAtoms++; } } if (kndex==0) kndex = nAtoms+1; if (!crModel) SwitchModel ( 1 ); RC = AllocateAtom ( kndex,chainID,chainID,resName,resName, seqNum,seqNum,1,insCode,True ); if (!RC) Atom[kndex-1]->SetAtomName ( kndex,serNum,atomName,altLoc, segID,element ); return RC; } int CMMDBFile::PutAtom ( int index, // same meaning as above PCAtom A, // pointer to completed atom // class int serNum // 0 means that the serial // number will be set equal // to "index". Otherwise, // the serial number is set // to the specified value ) { int i,kndex,RC,sn; if (!A) return -1; kndex = index; if (kndex<0) { // the new atom is to be inserted kndex = -kndex; if (kndex>AtmLen) ExpandAtomArray ( kndex+1000-AtmLen ); if (Atom[kndex-1]!=NULL) { // the position is occupied // expand the array if necessary if (nAtoms>=AtmLen) ExpandAtomArray ( IMax(kndex,nAtoms)+1000-AtmLen ); // now shift all atoms from (kndex-1)th to the end of array. // note that this does not affect residues as they keep only // pointers on atoms for (i=nAtoms;i>=kndex;i--) { Atom[i] = Atom[i-1]; Atom[i]->index = i+1; // this is Ok because residues keep // POINTERS rather than indices! } Atom[kndex-1] = NULL; nAtoms++; } } if (kndex==0) kndex = nAtoms+1; RC = AllocateAtom ( kndex,A->GetChainID(),A->GetLabelAsymID(), A->GetResName(),A->GetLabelCompID(), A->GetSeqNum (),A->GetLabelSeqID (), A->GetLabelEntityID(),A->GetInsCode(), True ); if (serNum<=0) sn = kndex; else sn = serNum; if (!RC) { Atom[kndex-1]->Copy ( A ); Atom[kndex-1]->serNum = sn; } return RC; } int CMMDBFile::CheckInAtom ( int index, // same meaning as above PCAtom A // pointer to completed // atom class ) { int i,kndex; if (!A) return -1; kndex = index; if (kndex<0) { // the new atom is to be inserted kndex = -kndex; if (kndex>AtmLen) ExpandAtomArray ( kndex+1000-AtmLen ); if (Atom[kndex-1]!=NULL) { // the position is occupied // expand the array if necessary if (nAtoms>=AtmLen) ExpandAtomArray ( IMax(kndex,nAtoms)+1000-AtmLen ); // now shift all atoms from (kndex-1)th to the end of array. // note that this does not affect residues as they keep only // pointers on atoms for (i=nAtoms;i>=kndex;i--) { Atom[i] = Atom[i-1]; if (Atom[i]) Atom[i]->index = i+1; // this is Ok because residues keep // POINTERS rather than indices! } } nAtoms++; } else { if (kndex==0) kndex = nAtoms + 1; // add atom on the very top if (kndex>AtmLen) ExpandAtomArray ( kndex+1000-AtmLen ); if (kndex>nAtoms) nAtoms = kndex; if (Atom[kndex-1]) delete Atom[kndex-1]; } Atom[kndex-1] = A; A->index = kndex; return 0; } int CMMDBFile::CheckInAtoms ( int index, // same meaning as above PPCAtom A, // array of atoms to check in int natms // number of atoms to check in ) { PPCAtom A1; int i,j,k,k1,kndex; if (!A) return -1; A1 = NULL; kndex = index; if (kndex<0) { // the new atoms are to be inserted kndex = -kndex; if (nAtoms+natms>=AtmLen) ExpandAtomArray ( IMax(kndex,nAtoms)+1000+natms-AtmLen ); if (kndexindex = k+1; k++; } if (j>0) { // insert removed atoms into the gap nAtoms += j; k1 = k+j; for (i=nAtoms-1;i>=k1;i--) { Atom[i] = Atom[i-j]; if (Atom[i]) Atom[i]->index = i+1; // this is Ok because residues keep // POINTERS rather than indices! } for (i=0;iindex = k+1; k++; } } delete[] A1; } else { if (kndex==0) kndex = nAtoms + 1; // add atom on the very top k = kndex + natms; if (k>AtmLen) ExpandAtomArray ( k+1000-AtmLen ); kndex--; for (i=0;iindex = kndex+1; kndex++; } nAtoms = IMax(nAtoms,kndex); } return 0; } int CMMDBFile::SwitchModel ( cpstr L ) { int nM; if (!GetInteger(nM,&(L[10]),4)) return Error_UnrecognizedInteger; return SwitchModel ( nM ); } int CMMDBFile::SwitchModel ( int nM ) { PPCModel Mdl; int i; Boolean Transfer; if (nM<=0) return Error_WrongModelNo; if (nM>nModels) { if ((nModels==1) && Model[0]) Transfer = (nAtoms<=0); else Transfer = False; Mdl = new PCModel[nM]; for (i=0;iSetMMDBManager ( PCMMDBManager(this),nM ); crModel = Model[nM-1]; crChain = NULL; // new model - new chain crRes = NULL; // new chain - new residue return 0; } int CMMDBFile::CheckAtomPlace ( int index, cpstr L ) { // This function gets the residue/chain information stored // in PDB string L (the records should start with the // keywords ATOM, SIGATM, ANISOU, SIGUIJ, TER, HETATM) and // sets the pointers crChain and crRes to the respective. // chain and residue. If there is no chain/residue to place // the atom in, these will be created. // The function prepares place for the atom in the index-th // cell of the Atom array, expanding it as necessary. If the // corresponding element in the Atom array was not initialized, // a CAtom class is created with reference to the current // residue. // This function DOES NOT check the PDB string L for // atom keywords. ResName resName; int seqNum; ChainID chainID; InsCode insCode; // get the residue sequence number/ insert code if (!GetIntIns(seqNum,insCode,&(L[22]),4)) { if (strncmp(L,"TER ",6)) return Error_UnrecognizedInteger; else { // we allow for empty TER card here seqNum = 0; insCode[0] = char(1); // unprintable symbol! used as // flag that TER card does not // have serial number insCode[1] = char(0); } } // get chain ID if (L[20]!=' ') { chainID[0] = L[20]; chainID[1] = L[21]; chainID[2] = char(0); } else if (L[21]!=' ') { chainID[0] = L[21]; chainID[1] = char(0); } else chainID[0] = char(0); // get residue name strcpy_ncss ( resName,&(L[17]),3 ); if ((!resName[0]) && (!strncmp(L,"TER ",6))) { insCode[0] = char(1); insCode[1] = char(0); } return AllocateAtom ( index ,chainID,chainID,resName,resName, seqNum,seqNum,1,insCode,False ); } int CMMDBFile::CheckAtomPlace ( int index, PCMMCIFLoop Loop ) { // Version of CheckAtomPlace(..) for reading from CIF file. ResName resName,label_comp_id; int seqNum ,label_seq_id,label_entity_id,RC,k,nM; ChainID chainID,label_asym_id; InsCode insCode; pstr F; // Get the residue sequence number/insert code. They are // removed from the file after reading. k = index-1; // if (!CIFGetInteger1(seqNum,Loop,CIFTAG_LABEL_SEQ_ID,k)) if (!CIFGetInteger1(seqNum,Loop,CIFTAG_AUTH_SEQ_ID,k)) CIFGetString ( insCode,Loop,CIFTAG_NDB_HELIX_CLASS_PDB,k, sizeof(InsCode),pstr("") ); else { F = Loop->GetString ( CIFTAG_GROUP_PDB,k,RC ); if ((!F) || (RC)) return Error_CIF_EmptyRow; if (strcmp(F,"TER")) { seqNum = MinInt4; // only at reading CIF we allow this CIFGetString ( insCode,Loop,CIFTAG_NDB_HELIX_CLASS_PDB,k, sizeof(InsCode),pstr("") ); } else { // we allow for empty TER card here seqNum = 0; insCode[0] = char(1); // unprintable symbol! used as // flag that TER card does not // have serial number insCode[1] = char(0); } } CIFGetInteger1 ( label_seq_id ,Loop,CIFTAG_LABEL_SEQ_ID ,k ); CIFGetInteger1 ( label_entity_id,Loop,CIFTAG_LABEL_ENTITY_ID,k ); // get chain/residue ID CIFGetString ( chainID,Loop,CIFTAG_AUTH_ASYM_ID,k, sizeof(ChainID),pstr("") ); CIFGetString ( resName,Loop,CIFTAG_AUTH_COMP_ID,k, sizeof(ResName),pstr("") ); CIFGetString ( label_asym_id,Loop,CIFTAG_LABEL_ASYM_ID,k, sizeof(ChainID),pstr("") ); CIFGetString ( label_comp_id,Loop,CIFTAG_LABEL_COMP_ID,k, sizeof(ResName),pstr("") ); if (!resName[0]) strcpy ( resName,label_comp_id ); if (!CIFGetInteger1(nM,Loop,CIFTAG_PDBX_PDB_MODEL_NUM,k)) { if (crModel) { if (nM!=crModel->serNum) SwitchModel ( nM ); } else SwitchModel ( nM ); } return AllocateAtom ( index ,chainID,label_asym_id,resName, label_comp_id,seqNum,label_seq_id, label_entity_id,insCode,False ); } int CMMDBFile::AllocateAtom ( int index, const ChainID chainID, const ChainID label_asym_id, const ResName resName, const ResName label_comp_id, int seqNum, int label_seq_id, int label_entity_id, const InsCode insCode, Boolean Replace ) { if ((!resName[0]) && (insCode[0]!=char(1))) return Error_EmptyResidueName; // check if there is a pointer to model if (!crModel) { // the model pointer was not set. Check if there are // models already defined if (!Model) SwitchModel ( 1 ); // creates a model else return Error_NoModel; } if (crChain && (insCode[0]!=char(1))) { // If crChain is not NULL, the model pointer was not // changed and we may try to keep using crChain as // pointer to the being-read chain. However, we must // check that the record still belongs to the same chain. // All this does not work if insCode[0] is set to 1 // which indicates a special case of 'TER' card without // parameters. if (enforceUniqueChID) { // enforcing unique chain IDs should be used only in case // of multi-chain complexes where 1-letter chain IDs are // not enough to accomodate all chains. Then chains are // dynamically renamed like A0,A1,A2,.. etc. Therefore, we // check only first symbol here. if (chainID[0]!=crChain->chainID[0]) crChain = NULL; // the chain has to be changed } else if (strcmp(chainID,crChain->chainID)) crChain = NULL; // the chain has to be changed } if (!crChain) { // either the model or chain was changed -- get a new chain if (allowDuplChID) crChain = crModel->CreateChain ( chainID ); else crChain = crModel->GetChainCreate ( chainID, enforceUniqueChID ); crRes = NULL; // new chain - new residue } if (crRes && (insCode[0]!=char(1))) { // If crRes is not NULL, neither the model nor chain were // changed. Check if this record still belongs to the // same residue. // All this does not work if insCode[0] is set to 1 // which indicates a special case of 'TER' card without // parameters. if ((seqNum!=crRes->seqNum) || strcmp(insCode,crRes->insCode) || strcmp(resName,crRes->name)) crRes = NULL; // the residue has to be changed } if (!crRes) { // either the chain or residue was changed -- get a new residue crRes = crChain->GetResidueCreate ( resName,seqNum,insCode, Flags & MMDBF_IgnoreDuplSeqNum ); if (!crRes) return Error_DuplicateSeqNum; } strcpy ( crRes->label_asym_id,label_asym_id ); strcpy ( crRes->label_comp_id,label_comp_id ); crRes->label_seq_id = label_seq_id; crRes->label_entity_id = label_entity_id; // now check if there is place in the Atom array if (index>AtmLen) // there is no place, expand Atom by 1000 atom places at once ExpandAtomArray ( index+1000-AtmLen ); nAtoms = IMax(nAtoms,index); // delete the to-be-replaced atom if there is any if (Replace && Atom[index-1]) { delete Atom[index-1]; Atom[index-1] = NULL; } if (!Atom[index-1]) { Atom[index-1] = newCAtom(); crRes->_AddAtom ( Atom[index-1] ); Atom[index-1]->index = index; } return 0; } void CMMDBFile::ExpandAtomArray ( int inc ) { // Expands the Atom array by adding more inc positions. // The length of Atom array is increased unconditionally. PPCAtom Atom1; int i; AtmLen += inc; Atom1 = new PCAtom[AtmLen]; for (i=0;iAtmLen) { AtmLen = nAtoms+inc; Atom1 = new PCAtom[AtmLen]; for (i=0;iPDBASCIIDumpPS ( f ); // output cispep records for (i=0;iPDBASCIIDumpCP ( f ); SA .PDBASCIIDump ( f ); Footnote.PDBASCIIDump ( f ); Cryst .PDBASCIIDump ( f ); SB .PDBASCIIDump ( f ); for (i=0;iPDBASCIIDump ( f ); SC.PDBASCIIDump ( f ); f.WriteLine ( pstr("END") ); } int CMMDBFile::WriteCIFASCII1 ( cpstr CIFLFName, byte gzipMode ) { pstr FName; FName = getenv ( CIFLFName ); if (FName) return WriteCIFASCII ( FName,gzipMode ); else return Error_NoLogicalName; } int CMMDBFile::WriteCIFASCII ( cpstr CIFFileName, byte gzipMode ) { int i; if (!CIF) CIF = new CMMCIFData(); CIF->SetStopOnWarning ( True ); CIF->SetPrintWarnings ( (Flags & MMDBF_PrintCIFWarnings)!=0 ); FType = MMDB_FILE_CIF; Title.MakeCIF ( CIF ); i = 0; while (iMakePSCIF ( CIF ); Cryst.MakeCIF ( CIF ); for (i=0;iMakeAtomCIF ( CIF ); CIF->Optimize(); CIF->WriteMMCIFData ( CIFFileName,gzipMode ); return 0; } PCAtom CMMDBFile::GetAtomI ( int index ) { if (index>nAtoms) return NULL; if (index<1) return NULL; if (!Atom) return NULL; return Atom[index-1]; } #define MMDBFLabel "**** This is MMDB binary file ****" #define Edition 1 int CMMDBFile::ReadMMDBF1 ( cpstr MMDBLFName, byte gzipMode ) { pstr FName; FName = getenv ( MMDBLFName ); if (FName) return ReadCoorFile ( FName,gzipMode ); else return Error_NoLogicalName; } int CMMDBFile::ReadMMDBF ( cpstr MMDBFileName, byte gzipMode ) { CFile f; int rc; f.assign ( MMDBFileName,False,True,gzipMode ); FType = MMDB_FILE_Binary; if (f.reset(True)) { rc = ReadMMDBF ( f ); f.shut(); } else rc = Error_CantOpenFile; return rc; } int CMMDBFile::ReadMMDBF ( RCFile f ) { char Label[100]; byte Version; FType = MMDB_FILE_Binary; f.ReadFile ( Label,sizeof(MMDBFLabel) ); if (strncmp(Label,MMDBFLabel,sizeof(MMDBFLabel))) return Error_ForeignFile; f.ReadByte ( &Version ); if (Version>Edition) return Error_WrongEdition; read ( f ); return 0; } int CMMDBFile::WriteMMDBF1 ( cpstr MMDBLFName, byte gzipMode ) { pstr FName; FName = getenv ( MMDBLFName ); if (FName) return WriteMMDBF ( FName,gzipMode ); else return Error_NoLogicalName; } int CMMDBFile::WriteMMDBF ( cpstr MMDBFileName, byte gzipMode ) { char Label[100]; byte Version=Edition; CFile f; f.assign ( MMDBFileName,False,True,gzipMode ); FType = MMDB_FILE_Binary; if (f.rewrite()) { strcpy ( Label,MMDBFLabel ); f.WriteFile ( Label,sizeof(MMDBFLabel) ); f.WriteByte ( &Version ); write ( f ); f.shut(); } else return Error_CantOpenFile; return 0; } pstr CMMDBFile::GetEntryID() { return Title.idCode; } void CMMDBFile::SetEntryID ( const IDCode idCode ) { strcpy ( Title.idCode,idCode ); } void CMMDBFile::SetSyminfoLib ( cpstr syminfo_lib ) { Cryst.SetSyminfoLib ( syminfo_lib ); } pstr CMMDBFile::GetSyminfoLib() { return Cryst.GetSyminfoLib(); } int CMMDBFile::SetSpaceGroup ( cpstr spGroup ) { return Cryst.SetSpaceGroup ( spGroup ); } pstr CMMDBFile::GetSpaceGroup() { return Cryst.GetSpaceGroup(); } pstr CMMDBFile::GetSpaceGroupFix() { return Cryst.GetSpaceGroupFix(); } void CMMDBFile::GetAtomStatistics ( RSAtomStat AS ) { int i; AS.Init(); for (i=0;iCalcAtomStatistics ( AS ); AS.Finish(); } void CMMDBFile::SetIgnoreSCALEi ( Boolean ignoreScalei ) { Cryst.ignoreScalei = ignoreScalei; } void CMMDBFile::SetCell ( realtype cell_a, realtype cell_b, realtype cell_c, realtype cell_alpha, realtype cell_beta, realtype cell_gamma, int OrthCode ) { Cryst.SetCell ( cell_a,cell_b,cell_c,cell_alpha,cell_beta, cell_gamma,OrthCode ); } void CMMDBFile::PutCell ( realtype cell_a, realtype cell_b, realtype cell_c, realtype cell_alpha, realtype cell_beta, realtype cell_gamma, int OrthCode ) { Cryst.PutCell ( cell_a,cell_b,cell_c,cell_alpha,cell_beta, cell_gamma,OrthCode ); } int CMMDBFile::GetCell ( realtype & cell_a, realtype & cell_b, realtype & cell_c, realtype & cell_alpha, realtype & cell_beta, realtype & cell_gamma, realtype & vol, int & OrthCode ) { if (Cryst.WhatIsSet & CSET_CellParams) { Cryst.GetCell ( cell_a,cell_b,cell_c,cell_alpha,cell_beta, cell_gamma,vol ); OrthCode = Cryst.NCode + 1; return 1; } else { cell_a = 0.0; cell_b = 0.0; cell_c = 0.0; cell_alpha = 0.0; cell_beta = 0.0; cell_gamma = 0.0; vol = 0.0; OrthCode = 0; return 0; } } int CMMDBFile::GetRCell ( realtype & cell_as, realtype & cell_bs, realtype & cell_cs, realtype & cell_alphas, realtype & cell_betas, realtype & cell_gammas, realtype & vols, int & OrthCode ) { if (Cryst.WhatIsSet & CSET_CellParams) { Cryst.GetRCell ( cell_as,cell_bs,cell_cs,cell_alphas,cell_betas, cell_gammas,vols ); OrthCode = Cryst.NCode + 1; return 1; } else { cell_as = 0.0; cell_bs = 0.0; cell_cs = 0.0; cell_alphas = 0.0; cell_betas = 0.0; cell_gammas = 0.0; vols = 0.0; OrthCode = 0; return 0; } } int CMMDBFile::GetNumberOfSymOps() { if (Cryst.WhatIsSet & CSET_SpaceGroup) return Cryst.GetNumberOfSymOps(); else return 0; } pstr CMMDBFile::GetSymOp ( int Nop ) { return Cryst.GetSymOp ( Nop ); } void CMMDBFile::GetROMatrix ( mat44 & RO ) { Mat4Copy ( Cryst.RO,RO ); } int CMMDBFile::GetTMatrix ( mat44 & TMatrix, int Nop, int cellshift_a, int cellshift_b, int cellshift_c ) { // GetTMatrix(..) calculates and returns the coordinate transformation // matrix, which converts orthogonal coordinates according to // the symmetry operation number Nop and places them into unit cell // shifted by cellshift_a a's, cellshift_b b's and cellshift_c c's. // // Return 0 means everything's fine, // 1 there's no symmetry operation Nop defined // 2 fractionalizing/orthogonalizing matrices were not // calculated // 3 cell parameters were not set up. return Cryst.GetTMatrix ( TMatrix,Nop,cellshift_a,cellshift_b, cellshift_c,NULL ); } int CMMDBFile::GetUCTMatrix ( mat44 & TMatrix, int Nop, realtype x, realtype y, realtype z, int cellshift_a, int cellshift_b, int cellshift_c ) { // GetUCTMatrix(..) calculates and returns the coordinate // transformation matrix, which converts orthogonal coordinates // according to the symmetry operation number Nop. Translation // part of the resulting matrix is being chosen such that point // (x,y,z) has least distance to the center of primary (333) // unit cell, and then it is shifted by cellshift_a a's, // cellshift_b b's and cellshift_c c's. // // Return 0 means everything's fine, // 1 there's no symmetry operation Nop defined // 2 fractionalizing/orthogonalizing matrices were not // calculated // 3 cell parameters were not set up. return Cryst.GetUCTMatrix ( TMatrix,Nop,x,y,z, cellshift_a,cellshift_b,cellshift_c, NULL ); } int CMMDBFile::GetFractMatrix ( mat44 & TMatrix, int Nop, int cellshift_a, int cellshift_b, int cellshift_c ) { // GetFractMatrix(..) calculates and returns the coordinate // transformation matrix, which converts fractional coordinates // according to the symmetry operation number Nop and places them // into unit cell shifted by cellshift_a a's, cellshift_b b's and // cellshift_c c's. // // Return 0 means everything's fine, // 1 there's no symmetry operation Nop defined // 2 fractionalizing/orthogonalizing matrices were not // calculated // 3 cell parameters were not set up. return Cryst.GetFractMatrix ( TMatrix,Nop,cellshift_a,cellshift_b, cellshift_c,NULL ); } int CMMDBFile::GetSymOpMatrix ( mat44 & TMatrix, int Nop ) { // // GetSymOpMatrix(..) returns the transformation matrix for // Nop-th symmetry operator in the space group // // Return 0 means everything's fine, // 1 there's no symmetry operation Nop defined // 2 fractionalizing/orthogonalizing matrices were not // calculated // 3 cell parameters were not set up. // return Cryst.GetSymOpMatrix ( TMatrix,Nop ); } // ------------- User-Defined Data ------------------------ int CMMDBFile::RegisterUDInteger ( int udr_type, cpstr UDDataID ) { return UDRegister.RegisterUDInteger ( udr_type,UDDataID ); } int CMMDBFile::RegisterUDReal ( int udr_type, cpstr UDDataID ) { return UDRegister.RegisterUDReal ( udr_type,UDDataID ); } int CMMDBFile::RegisterUDString ( int udr_type, cpstr UDDataID ) { return UDRegister.RegisterUDString ( udr_type,UDDataID ); } int CMMDBFile::GetUDDHandle ( int udr_type, cpstr UDDataID ) { return UDRegister.GetUDDHandle ( udr_type,UDDataID ); } // ---------------------------------------------------------- int CMMDBFile::DeleteAllModels() { int i,k; Exclude = False; k = 0; for (i=0;i=1) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->GetNewChainID ( chID,length ); } return False; } // ------------------------------------------------------------- PCMask CMMDBFile::GetSelMask ( int selHnd ) { UNUSED_ARGUMENT(selHnd); return NULL; } // ------------------------------------------------------------- int CMMDBFile::GetNofExpDataRecs() { return Title.ExpData.Length(); } pstr CMMDBFile::GetExpDataRec ( int recNo ) { PCExpData expData; expData = PCExpData(Title.ExpData.GetContainerClass(recNo)); if (expData) return expData->Line; return NULL; } // ------------------------------------------------------------- int CMMDBFile::GetNofMdlTypeRecs() { return Title.MdlType.Length(); } pstr CMMDBFile::GetMdlTypeRec ( int recNo ) { PCMdlType mdlType; mdlType = PCMdlType(Title.MdlType.GetContainerClass(recNo)); if (mdlType) return mdlType->Line; return NULL; } // ------------------- Stream functions ---------------------- void CMMDBFile::Copy ( PCMMDBFile MMDBFile ) { int i; Title.Copy ( &MMDBFile->Title ); Cryst.Copy ( &MMDBFile->Cryst ); // It is important to copy atoms _before_ models, // residues and chains! Flags = MMDBFile->Flags; nAtoms = MMDBFile->nAtoms; AtmLen = nAtoms; if (nAtoms>0) { Atom = new PCAtom[AtmLen]; for (i=0;iAtom[i]) { Atom[i] = newCAtom(); Atom[i]->Copy ( MMDBFile->Atom[i] ); Atom[i]->index = i+1; // the internal atom references are installed // by residue classes when they are copied in // model->chain below } else Atom[i] = NULL; } nModels = MMDBFile->nModels; if (nModels>0) { Model = new PCModel[nModels]; for (i=0;iModel[i]) { Model[i] = newCModel(); Model[i]->SetMMDBManager ( PCMMDBManager(this),i+1 ); Model[i]->_copy ( MMDBFile->Model[i] ); } else Model[i] = NULL; } } SA .Copy ( &MMDBFile->SA ); Footnote.Copy ( &MMDBFile->Footnote ); SB .Copy ( &MMDBFile->SB ); SC .Copy ( &MMDBFile->SC ); if (MMDBFile->CIF) { CIF = new CMMCIFData; CIF->Copy ( MMDBFile->CIF ); } } // ------- user-defined data handlers int CMMDBFile::PutUDData ( int UDDhandle, int iudd ) { if (UDDhandle & UDRF_HIERARCHY) return CUDData::putUDData ( UDDhandle,iudd ); else return UDDATA_WrongUDRType; } int CMMDBFile::PutUDData ( int UDDhandle, realtype rudd ) { if (UDDhandle & UDRF_HIERARCHY) return CUDData::putUDData ( UDDhandle,rudd ); else return UDDATA_WrongUDRType; } int CMMDBFile::PutUDData ( int UDDhandle, cpstr sudd ) { if (UDDhandle & UDRF_HIERARCHY) return CUDData::putUDData ( UDDhandle,sudd ); else return UDDATA_WrongUDRType; } int CMMDBFile::GetUDData ( int UDDhandle, int & iudd ) { if (UDDhandle & UDRF_HIERARCHY) return CUDData::getUDData ( UDDhandle,iudd ); else return UDDATA_WrongUDRType; } int CMMDBFile::GetUDData ( int UDDhandle, realtype & rudd ) { if (UDDhandle & UDRF_HIERARCHY) return CUDData::getUDData ( UDDhandle,rudd ); else return UDDATA_WrongUDRType; } int CMMDBFile::GetUDData ( int UDDhandle, pstr sudd, int maxLen ) { if (UDDhandle & UDRF_HIERARCHY) return CUDData::getUDData ( UDDhandle,sudd,maxLen ); else return UDDATA_WrongUDRType; } int CMMDBFile::GetUDData ( int UDDhandle, pstr & sudd ) { if (UDDhandle & UDRF_HIERARCHY) return CUDData::getUDData ( UDDhandle,sudd ); else return UDDATA_WrongUDRType; } pstr CMMDBFile::GetStructureTitle ( pstr & L ) { return Title.GetStructureTitle ( L ); } void CMMDBFile::SetShortBinary() { // leaves only coordinates in binary files int i; for (i=0;iSetShortBinary(); } void CMMDBFile::write ( RCFile f ) { int i,k; byte Version=1; f.WriteByte ( &Version ); CUDData::write ( f ); Title .write ( f ); Cryst .write ( f ); UDRegister.write ( f ); DefPath .write ( f ); f.WriteWord ( &Flags ); f.WriteInt ( &nAtoms ); for (i=0;iwrite ( f ); } f.WriteInt ( &nModels ); for (i=0;iwrite ( f ); } SA .write ( f ); Footnote.write ( f ); SB .write ( f ); SC .write ( f ); StreamWrite ( f,CIF ); } void CMMDBFile::read ( RCFile f ) { int i,k; byte Version; ResetManager (); FreeFileMemory(); f.ReadByte ( &Version ); CUDData::read ( f ); Title .read ( f ); Cryst .read ( f ); UDRegister.read ( f ); DefPath .read ( f ); // It is important to read atoms before models, // residues and chains! f.ReadWord ( &Flags ); f.ReadInt ( &nAtoms ); AtmLen = nAtoms; if (nAtoms>0) { Atom = new PCAtom[AtmLen]; for (i=0;iread ( f ); // the internal atom references are installed // by residue classes when they are read in // model->chain below } else Atom[i] = NULL; } } f.ReadInt ( &nModels ); if (nModels>0) { Model = new PCModel[nModels]; for (i=0;iSetMMDBManager ( PCMMDBManager(this),0 ); Model[i]->read ( f ); } else Model[i] = NULL; } } SA .read ( f ); Footnote.read ( f ); SB .read ( f ); SC .read ( f ); StreamRead ( f,CIF ); } MakeStreamFunctions(CMMDBFile) int isMMDBBIN ( cpstr FName, byte gzipMode ) { CFile f; int rc; f.assign ( FName,False,True,gzipMode ); if (f.reset(True)) { rc = isMMDBBIN ( f ); f.shut(); } else rc = -1; return rc; } int isMMDBBIN ( RCFile f ) { char Label[100]; byte Version; if (f.FileEnd()) return Error_EmptyFile; f.ReadFile ( Label,sizeof(MMDBFLabel) ); if (strncmp(Label,MMDBFLabel,sizeof(MMDBFLabel))) return 1; f.ReadByte ( &Version ); if (Version>Edition) return 2; else return 0; } int isPDB ( cpstr FName, byte gzipMode, Boolean IgnoreBlankLines ) { CFile f; int rc; f.assign ( FName,False,False,gzipMode ); if (f.reset(True)) { // opening it in pseudo-binary mode helps reading various // line terminators for files coming from different platforms rc = isPDB ( f,IgnoreBlankLines ); f.shut(); } else rc = -1; return rc; } int isPDB ( RCFile f, Boolean IgnoreBlankLines ) { char S[256]; int i; Boolean Done; if (f.FileEnd()) return Error_EmptyFile; do { Done = True; f.ReadLine ( S,sizeof(S)-1 ); if (IgnoreBlankLines) { i = 0; while (S[i] && (S[i]==' ')) i++; if (!S[i]) Done = False; } } while ((!f.FileEnd()) && (!Done)); PadSpaces ( S,80 ); if (!strncasecmp(S,"HEADER",6)) return 0; if (!strncasecmp(S,"OBSLTE",6)) return 0; if (!strncasecmp(S,"TITLE ",6)) return 0; if (!strncasecmp(S,"CAVEAT",6)) return 0; if (!strncasecmp(S,"COMPND",6)) return 0; if (!strncasecmp(S,"SOURCE",6)) return 0; if (!strncasecmp(S,"KEYWDS",6)) return 0; if (!strncasecmp(S,"EXPDTA",6)) return 0; if (!strncasecmp(S,"AUTHOR",6)) return 0; if (!strncasecmp(S,"REVDAT",6)) return 0; if (!strncasecmp(S,"SPRSDE",6)) return 0; if (!strncasecmp(S,"JRNL ",6)) return 0; if (!strncasecmp(S,"REMARK",6)) return 0; if (!strncasecmp(S,"DBREF ",6)) return 0; if (!strncasecmp(S,"SEQADV",6)) return 0; if (!strncasecmp(S,"SEQRES",6)) return 0; if (!strncasecmp(S,"MODRES",6)) return 0; if (!strncasecmp(S,"HET ",6)) return 0; if (!strncasecmp(S,"HETNAM",6)) return 0; if (!strncasecmp(S,"HETSYN",6)) return 0; if (!strncasecmp(S,"FORMUL",6)) return 0; if (!strncasecmp(S,"HELIX ",6)) return 0; if (!strncasecmp(S,"SHEET ",6)) return 0; if (!strncasecmp(S,"TURN ",6)) return 0; if (!strncasecmp(S,"SSBOND",6)) return 0; if (!strncasecmp(S,"LINK ",6)) return 0; if (!strncasecmp(S,"HYDBND",6)) return 0; if (!strncasecmp(S,"SLTBRG",6)) return 0; if (!strncasecmp(S,"CISPEP",6)) return 0; if (!strncasecmp(S,"SITE ",6)) return 0; if (!strncasecmp(S,"CRYST1",6)) return 0; if (!strncasecmp(S,"CRYST ",6)) return 0; if (!strncasecmp(S,"ORIGX1",6)) return 0; if (!strncasecmp(S,"ORIGX2",6)) return 0; if (!strncasecmp(S,"ORIGX3",6)) return 0; if (!strncasecmp(S,"SCALE1",6)) return 0; if (!strncasecmp(S,"SCALE2",6)) return 0; if (!strncasecmp(S,"SCALE3",6)) return 0; if (!strncasecmp(S,"MTRIX1",6)) return 0; if (!strncasecmp(S,"MTRIX2",6)) return 0; if (!strncasecmp(S,"MTRIX3",6)) return 0; if (!strncasecmp(S,"TVECT ",6)) return 0; if (!strncasecmp(S,"MODEL ",6)) return 0; if (!strncasecmp(S,"ATOM ",6)) return 0; if (!strncasecmp(S,"SIGATM",6)) return 0; if (!strncasecmp(S,"ANISOU",6)) return 0; if (!strncasecmp(S,"SIGUIJ",6)) return 0; if (!strncasecmp(S,"TER ",6)) return 0; if (!strncasecmp(S,"HETATM",6)) return 0; if (!strncasecmp(S,"ENDMDL",6)) return 0; if (!strncasecmp(S,"CONECT",6)) return 0; if (!strncasecmp(S,"MASTER",6)) return 0; if (!strncasecmp(S,"END ",6)) return 0; if (!strncasecmp(S,"USER ",6)) return 0; return 1; } mmdb-1.25.5/mmdb/mmdb_align.cpp0000775000175000017500000007273211736610510013200 00000000000000// $Id: mmdb_align.cpp,v 1.22 2012/01/26 17:52:20 ekr Exp $ // ================================================================= // // CCP4 Coordinate Library: support of coordinate-related // functionality in protein crystallography applications. // // Copyright (C) Eugene Krissinel 2000-2008. // // This library is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // // ================================================================= // // 19.04.11 <-- Date of Last Modification. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ----------------------------------------------------------------- // // **** Module : MMDB_Align // ~~~~~~~~~ // **** Classes : CAlignment ( alignment of character strings ) // ~~~~~~~~~~~~ CAlignment1 ( alignment of integer vectors ) // // (C) E.Krissinel' 2000-2011 // // ================================================================= // #ifndef __STRING_H #include #endif #ifndef __MATH_H #include #endif #ifndef __MMDB_Align__ #include "mmdb_align.h" #endif // ===================== CAligParams ====================== CAlignParams::CAlignParams() : CStream() { InitAlignParams(); } CAlignParams::CAlignParams ( RPCStream Object ) : CStream ( Object ) { InitAlignParams(); } void CAlignParams::InitAlignParams() { gapWeight = -1.0; spaceWeight = -1.0; equalScore = 2.0; nequalScore = -1.0; method = ALIGN_GLOBAL; } void CAlignParams::write ( RCFile f ) { f.WriteReal ( &gapWeight ); f.WriteReal ( &spaceWeight ); f.WriteReal ( &equalScore ); f.WriteReal ( &nequalScore ); f.WriteInt ( &method ); } void CAlignParams::read ( RCFile f ) { f.ReadReal ( &gapWeight ); f.ReadReal ( &spaceWeight ); f.ReadReal ( &equalScore ); f.ReadReal ( &nequalScore ); f.ReadInt ( &method ); } MakeStreamFunctions(CAlignParams) // ===================== CAlignment ====================== CAlignment::CAlignment() : CStream() { InitAlignment(); } CAlignment::CAlignment ( RPCStream Object ) : CStream ( Object ) { InitAlignment(); } CAlignment::~CAlignment() { FreeMemory(); } void CAlignment::InitAlignment() { Space = '-'; SLen = 0; TLen = 0; VT = NULL; ET = NULL; FT = NULL; AlgnS = NULL; AlgnT = NULL; AlignKey = ALIGN_GLOBAL; VAchieved = 0.0; SEq = 2.0; SNEq = -1.0; Wg = 0.0; Ws = -1.0; } void CAlignment::FreeMemory() { FreeMatrixMemory ( VT,TLen+1,0,0 ); FreeMatrixMemory ( ET,TLen+1,0,0 ); FreeMatrixMemory ( FT,TLen+1,0,0 ); if (AlgnS) { delete[] AlgnS; AlgnS = NULL; } if (AlgnT) { delete[] AlgnT; AlgnT = NULL; } TLen = 0; SLen = 0; } void CAlignment::SetAffineModel ( realtype WGap, realtype WSpace ) { Wg = WGap; Ws = WSpace; } void CAlignment::SetScores ( realtype SEqual, realtype SNEqual ) { SEq = SEqual; SNEq = SNEqual; } void CAlignment::Align ( cpstr S, cpstr T, int Method ) { int i,j,i0,j0; FreeMemory(); AlignKey = Method; switch (Method) { default : case ALIGN_GLOBAL : // global pairwise alignment of S and T BuildGATable ( S,T, False,False ); VAchieved = VT[TLen][SLen]; Backtrace ( S,T,SLen,TLen,False ); if ((AlgnS[0]!=Space) && (AlgnT[0]!=Space)) VAchieved -= Wg; break; case ALIGN_LOCAL : // local pairwise alignment of S and T BuildLATable ( S,T ); VAchieved = 0.0; i0 = -1; j0 = -1; for (i=0;i<=TLen;i++) for (j=0;j<=SLen;j++) if (VT[i][j]>VAchieved) { VAchieved = VT[i][j]; i0 = i; j0 = j; } Backtrace ( S,T,j0,i0,True ); break; case ALIGN_GLOBLOC : // global alignment with non-penalized // end gaps in T BuildGATable ( S,T,False,True ); VAchieved = -MaxReal; i0 = -1; j0 = -1; for (i=0;i<=TLen;i++) if (VT[i][SLen]>VAchieved) { VAchieved = VT[i][SLen]; i0 = i; j0 = SLen; } Backtrace ( S,T,j0,i0,False ); AdjustEnds ( S,T,j0,i0 ); break; case ALIGN_FREEENDS : // global alignment with non-penalized // end gaps in both S and T BuildGATable ( S,T,True,True ); VAchieved = -MaxReal; i0 = -1; j0 = -1; for (i=0;i<=TLen;i++) if (VT[i][SLen]>VAchieved) { VAchieved = VT[i][SLen]; i0 = i; j0 = SLen; } for (j=0;j<=SLen;j++) if (VT[TLen][j]>VAchieved) { VAchieved = VT[TLen][j]; i0 = TLen; j0 = j; } Backtrace ( S,T,j0,i0,False ); AdjustEnds ( S,T,j0,i0 ); } } void CAlignment::BuildGATable ( cpstr S, cpstr T, Boolean FreeSEnd, Boolean FreeTEnd ) { int i,j; realtype V1; SLen = strlen ( S ); TLen = strlen ( T ); GetMatrixMemory ( VT,TLen+1,SLen+1,0,0 ); GetMatrixMemory ( ET,TLen+1,SLen+1,0,0 ); GetMatrixMemory ( FT,TLen+1,SLen+1,0,0 ); // Base conditions if (FreeSEnd || FreeTEnd) VT[0][0] = RMax(0.0,Wg); else VT[0][0] = Wg; ET[0][0] = VT[0][0]; FT[0][0] = VT[0][0]; if (FreeTEnd) for (i=1;i<=TLen;i++) { V1 = RMax ( 0.0,VT[i-1][0]+Ws ); VT[i][0] = V1; ET[i][0] = V1; } else for (i=1;i<=TLen;i++) { V1 = VT[i-1][0] + Ws; VT[i][0] = V1; ET[i][0] = V1; } if (FreeSEnd) for (j=1;j<=SLen;j++) { V1 = RMax ( 0.0,VT[0][j-1]+Ws ); VT[0][j] = V1; FT[0][j] = V1; } else for (j=1;j<=SLen;j++) { V1 = VT[0][j-1] + Ws; VT[0][j] = V1; FT[0][j] = V1; } // Recurrence for (i=1;i<=TLen;i++) for (j=1;j<=SLen;j++) { V1 = VT[i-1][j-1] + Score(T[i-1],S[j-1]); ET[i][j] = RMax ( ET[i][j-1]+Ws,VT[i][j-1]+Wg+Ws ); FT[i][j] = RMax ( FT[i-1][j]+Ws,VT[i-1][j]+Wg+Ws ); VT[i][j] = RMax ( RMax(V1,ET[i][j]),FT[i][j] ); } FreeMatrixMemory ( ET,TLen+1,0,0 ); FreeMatrixMemory ( FT,TLen+1,0,0 ); // PrintVT ( S,T ); } void CAlignment::BuildLATable ( cpstr S, cpstr T ) { int i,j; realtype V1; SLen = strlen ( S ); TLen = strlen ( T ); GetMatrixMemory ( VT,TLen+1,SLen+1,0,0 ); GetMatrixMemory ( ET,TLen+1,SLen+1,0,0 ); GetMatrixMemory ( FT,TLen+1,SLen+1,0,0 ); // Base conditions VT[0][0] = RMax ( 0.0,Wg ); ET[0][0] = VT[0][0]; FT[0][0] = VT[0][0]; for (i=1;i<=TLen;i++) { V1 = RMax ( 0.0,VT[i-1][0]+Ws ); VT[i][0] = V1; ET[i][0] = V1; } for (j=1;j<=SLen;j++) { V1 = RMax ( 0.0,VT[0][j-1]+Ws ); VT[0][j] = V1; FT[0][j] = V1; } // Recurrence for (i=1;i<=TLen;i++) for (j=1;j<=SLen;j++) { V1 = VT[i-1][j-1] + Score(T[i-1],S[j-1]); ET[i][j] = RMax ( ET[i][j-1]+Ws,VT[i][j-1]+Wg+Ws ); FT[i][j] = RMax ( FT[i-1][j]+Ws,VT[i-1][j]+Wg+Ws ); VT[i][j] = RMax ( RMax(V1,ET[i][j]),RMax(0.0,FT[i][j]) ); } FreeMatrixMemory ( ET,TLen+1,0,0 ); FreeMatrixMemory ( FT,TLen+1,0,0 ); // PrintVT ( S,T ); } void CAlignment::PrintVT ( cpstr S, cpstr T ) { int i,j; printf ( "\n " ); for (j=0;j<=SLen;j++) printf ( " %2i",j ); printf ( " \n " ); for (j=1;j<=SLen;j++) printf ( " %c ",S[j-1] ); printf ( " \n\n " ); for (i=0;i<=TLen;i++) { if (i>0) printf ( " %2i %c ",i,T[i-1] ); else printf ( " %2i ",i ); for (j=0;j<=SLen;j++) printf ( " %2i",mround(VT[i][j]) ); printf ( " \n " ); } printf ( " \n" ); } void CAlignment::Backtrace ( cpstr S, cpstr T, int J, int I, Boolean StopAtZero ) { int i,j,k, i1,j1, sk,tk; char C; realtype V,SV,TV; Boolean Stop; // 1. Allocate memory if (AlgnS) delete[] AlgnS; if (AlgnT) delete[] AlgnT; i = SLen+TLen+1; AlgnS = new char[i]; AlgnT = new char[i]; memset ( AlgnS,Space,i ); memset ( AlgnT,Space,i ); // 2. Initialize backtracing i = I; // backtracing j = J; // indices k = 0; // alignment index SV = 0.0; sk = -1; // alignment indices and leading elements TV = 0.0; tk = -1; // for vertical and horizontal sections // 3. Backtracing Stop = False; while ((!Stop) && (i>0) && (j>0)) { V = VT[i][j]; // find next leading element if (VT[i][j-1]>VT[i-1][j]) { i1 = i; j1 = j-1; } else { i1 = i-1; j1 = j; } if (VT[i-1][j-1]>=VT[i1][j1]) { i1 = i-1; j1 = j-1; } //printf ( " i=%i j=%i \n",i,j ); Stop = StopAtZero && (VT[i1][j1]<=0.0); // used at local alignment // treat horizontal section if ((sk<0) || (V>SV)) { sk = k; SV = V; } if ((j1!=j) || Stop) { // end of horizontal section AlgnS[sk] = S[j-1]; sk = -1; } // treat vertical section if ((tk<0) || (V>TV)) { tk = k; TV = V; } if ((i1!=i) || Stop) { // end of vertical section AlgnT[tk] = T[i-1]; tk = -1; } i = i1; j = j1; k++; } if (!StopAtZero) { // 4. Finish the last horizontal section sk = k; while (j>0) AlgnS[k++] = S[--j]; // 5. Finish the last vertical section while (i>0) AlgnT[sk++] = T[--i]; k = IMax ( k,sk ); } // 6. Put the termination character AlgnS[k] = char(0); AlgnT[k] = char(0); // 7. Reverse the strings i = 0; j = k-1; if (StopAtZero) { // should work only for local alignment while ((j>0) && ((AlgnS[j]==Space) || (AlgnT[j]==Space))) j--; k = j+1; AlgnS[k] = char(0); AlgnT[k] = char(0); } while (j>i) { C = AlgnS[i]; AlgnS[i] = AlgnS[j]; AlgnS[j] = C; C = AlgnT[i]; AlgnT[i] = AlgnT[j]; AlgnT[j] = C; i++; j--; } // 8. Collapse the alternating spaces do { k = 0; i = 0; while (AlgnS[k]) { if ((AlgnS[k]==Space) && (AlgnT[k]==Space)) k++; else if ((AlgnS[k]==Space) && (AlgnS[k+1]!=Space) && (AlgnT[k]!=Space) && (AlgnT[k+1]==Space)) { AlgnS[i] = AlgnS[k+1]; AlgnT[i] = AlgnT[k]; k++; } else if ((AlgnS[k]!=Space) && (AlgnS[k+1]==Space) && (AlgnT[k]==Space) && (AlgnT[k+1]!=Space)) { AlgnS[i] = AlgnS[k]; AlgnT[i] = AlgnT[k+1]; k++; } else if (i!=k) { AlgnS[i] = AlgnS[k]; AlgnT[i] = AlgnT[k]; } if (AlgnS[k]) { k++; i++; } } if (i!=k) { // terminating character AlgnS[i] = AlgnS[k]; AlgnT[i] = AlgnT[k]; } } while (k>i); } void CAlignment::AdjustEnds ( cpstr S, cpstr T, int J, int I ) { int si,ti,m; if (JI) { k = J-I; strcat ( AlgnT,&(T[IMax(0,TLen-k)]) ); k = strlen ( AlgnS ); m = strlen ( AlgnT ); while (kJ) { k = I-J; strcat ( AlgnS,&(S[IMax(0,SLen-k)]) ); k = strlen ( AlgnT ); m = strlen ( AlgnS ); while (k0.0) && (a>0.0)) return s/a; return 0.0; } realtype CAlignment::GetSeqId() { realtype s; int i,n,ne,ns,nt; ne = 0; ns = 0; nt = 0; n = IMin ( strlen(AlgnS),strlen(AlgnT) ); for (i=0;i0.0) return ne/s; return 0.0; } #define WrapPeriod 61 void CAlignment::OutputResults ( RCFile f, cpstr S, cpstr T ) { int k,l,n; char P[3]; P[1] = char(0); if ((!AlgnS) || (!AlgnT)) { f.LF(); f.WriteLine ( pstr(" NO ALIGNMENT HAS BEEN DONE.") ); f.shut(); return; } f.LF(); f.WriteLine ( pstr(" ======== INPUT DATA") ); f.LF(); f.WriteLine ( pstr(" String S:") ); f.Write ( pstr(" ") ); l = 1; k = 0; while (S[k]) { P[0] = S[k++]; f.Write ( P ); l++; if (l>=WrapPeriod) { f.LF(); f.Write ( pstr(" ") ); l = 1; } } f.LF(); f.LF(); f.WriteLine ( pstr(" String T:") ); f.Write ( pstr(" ") ); l = 1; k = 0; while (T[k]) { P[0] = T[k++]; f.Write ( P ); l++; if (l>=WrapPeriod) { f.LF(); f.Write ( pstr(" ") ); l = 1; } } f.LF(); f.LF(); f.WriteParameter ( pstr(" Score equal") ,SEq ,20,10 ); f.WriteParameter ( pstr(" Score unequal"),SNEq,20,10 ); f.LF(); f.WriteParameter ( pstr(" Gap weight") ,Wg ,20,10 ); f.WriteParameter ( pstr(" Space weight") ,Ws ,20,10 ); f.LF(); f.LF(); f.Write ( pstr(" ======== RESULT OF ") ); switch (AlignKey) { default : case ALIGN_GLOBAL : f.Write ( pstr("GLOBAL") ); break; case ALIGN_LOCAL : f.Write ( pstr("LOCAL") ); break; case ALIGN_GLOBLOC : f.Write ( pstr("GLOBAL/LOCAL") ); break; case ALIGN_FREEENDS : f.Write ( pstr("FREE-ENDS") ); } f.WriteLine ( pstr(" ALIGNMENT") ); f.LF(); if (AlignKey==ALIGN_GLOBLOC) { f.WriteLine ( pstr(" End gaps in T-string were not penalized") ); f.LF(); } f.WriteParameter ( pstr(" Highest score achieved:"),VAchieved,26,10 ); f.LF(); f.WriteLine ( pstr(" Aligned S (upper string) and T (lower string):") ); f.LF(); k = 0; n = 0; l = 1; f.Write ( pstr(" ") ); while (AlgnS[k]) { P[0] = AlgnS[k++]; f.Write ( P ); l++; if ((l>=WrapPeriod) || (!AlgnS[k])) { f.LF(); f.Write ( pstr(" ") ); l = 1; while (AlgnT[n] && (lVAchieved) { VAchieved = VT[i][j]; i0 = i; j0 = j; } Backtrace ( S,T,j0,i0,True ); break; case ALIGN_GLOBLOC : // global alignment with non-penalized // end gaps in T BuildGATable ( S,T,False,True ); VAchieved = -MaxReal; i0 = -1; j0 = -1; for (i=0;i<=TLen;i++) if (VT[i][SLen]>VAchieved) { VAchieved = VT[i][SLen]; i0 = i; j0 = SLen; } Backtrace ( S,T,j0,i0,False ); AdjustEnds ( S,T,j0,i0 ); break; case ALIGN_FREEENDS : // global alignment with non-penalized // end gaps in both S and T BuildGATable ( S,T,True,True ); VAchieved = -MaxReal; i0 = -1; j0 = -1; for (i=0;i<=TLen;i++) if (VT[i][SLen]>VAchieved) { VAchieved = VT[i][SLen]; i0 = i; j0 = SLen; } for (j=0;j<=SLen;j++) if (VT[TLen][j]>VAchieved) { VAchieved = VT[TLen][j]; i0 = TLen; j0 = j; } Backtrace ( S,T,j0,i0,False ); AdjustEnds ( S,T,j0,i0 ); } } void CAlignment1::BuildGATable ( ivector S, ivector T, Boolean FreeSEnd, Boolean FreeTEnd ) { int i,j; realtype V1; GetMatrixMemory ( VT,TLen+1,SLen+1,0,0 ); GetMatrixMemory ( ET,TLen+1,SLen+1,0,0 ); GetMatrixMemory ( FT,TLen+1,SLen+1,0,0 ); // Base conditions if (FreeSEnd || FreeTEnd) VT[0][0] = RMax(0.0,Wg); else VT[0][0] = Wg; ET[0][0] = VT[0][0]; FT[0][0] = VT[0][0]; if (FreeTEnd) for (i=1;i<=TLen;i++) { V1 = RMax ( 0.0,VT[i-1][0]+Ws ); VT[i][0] = V1; ET[i][0] = V1; } else for (i=1;i<=TLen;i++) { V1 = VT[i-1][0] + Ws; VT[i][0] = V1; ET[i][0] = V1; } if (FreeSEnd) for (j=1;j<=SLen;j++) { V1 = RMax ( 0.0,VT[0][j-1]+Ws ); VT[0][j] = V1; FT[0][j] = V1; } else for (j=1;j<=SLen;j++) { V1 = VT[0][j-1] + Ws; VT[0][j] = V1; FT[0][j] = V1; } // Recurrence for (i=1;i<=TLen;i++) for (j=1;j<=SLen;j++) { V1 = VT[i-1][j-1] + Score(T[i-1],S[j-1]); ET[i][j] = RMax ( ET[i][j-1]+Ws,VT[i][j-1]+Wg+Ws ); FT[i][j] = RMax ( FT[i-1][j]+Ws,VT[i-1][j]+Wg+Ws ); VT[i][j] = RMax ( RMax(V1,ET[i][j]),FT[i][j] ); } FreeMatrixMemory ( ET,TLen+1,0,0 ); FreeMatrixMemory ( FT,TLen+1,0,0 ); // PrintVT ( S,T ); } void CAlignment1::BuildLATable ( ivector S, ivector T ) { int i,j; realtype V1; GetMatrixMemory ( VT,TLen+1,SLen+1,0,0 ); GetMatrixMemory ( ET,TLen+1,SLen+1,0,0 ); GetMatrixMemory ( FT,TLen+1,SLen+1,0,0 ); // Base conditions VT[0][0] = RMax ( 0.0,Wg ); ET[0][0] = VT[0][0]; FT[0][0] = VT[0][0]; for (i=1;i<=TLen;i++) { V1 = RMax ( 0.0,VT[i-1][0]+Ws ); VT[i][0] = V1; ET[i][0] = V1; } for (j=1;j<=SLen;j++) { V1 = RMax ( 0.0,VT[0][j-1]+Ws ); VT[0][j] = V1; FT[0][j] = V1; } // Recurrence for (i=1;i<=TLen;i++) for (j=1;j<=SLen;j++) { V1 = VT[i-1][j-1] + Score(T[i-1],S[j-1]); ET[i][j] = RMax ( ET[i][j-1]+Ws,VT[i][j-1]+Wg+Ws ); FT[i][j] = RMax ( FT[i-1][j]+Ws,VT[i-1][j]+Wg+Ws ); VT[i][j] = RMax ( RMax(V1,ET[i][j]),RMax(0.0,FT[i][j]) ); } FreeMatrixMemory ( ET,TLen+1,0,0 ); FreeMatrixMemory ( FT,TLen+1,0,0 ); // PrintVT ( S,T ); } void CAlignment1::PrintVT ( ivector S, ivector T ) { int i,j; printf ( "\n " ); for (j=0;j<=SLen;j++) printf ( " %2i",j ); printf ( " \n " ); for (j=1;j<=SLen;j++) printf ( " %3i ",S[j-1] ); printf ( " \n\n " ); for (i=0;i<=TLen;i++) { if (i>0) printf ( " %2i %3i ",i,T[i-1] ); else printf ( " %2i ",i ); for (j=0;j<=SLen;j++) printf ( " %2i",mround(VT[i][j]) ); printf ( " \n " ); } printf ( " \n" ); } void CAlignment1::Backtrace ( ivector S, ivector T, int J, int I, Boolean StopAtZero ) { int i,j,k, i1,j1, sk,tk; int C; realtype V,SV,TV; Boolean Stop; // 1. Allocate memory FreeVectorMemory ( AlgnS,0 ); FreeVectorMemory ( AlgnT,0 ); AlgnLen = 0; k = SLen+TLen+1; GetVectorMemory ( AlgnS,k,0 ); GetVectorMemory ( AlgnT,k,0 ); for (i=0;i0) && (j>0)) { V = VT[i][j]; // find next leading element if (VT[i][j-1]>VT[i-1][j]) { i1 = i; j1 = j-1; } else { i1 = i-1; j1 = j; } if (VT[i-1][j-1]>=VT[i1][j1]) { i1 = i-1; j1 = j-1; } Stop = StopAtZero && (VT[i1][j1]<=0.0); // used at local alignment // treat horizontal section if ((sk<0) || (V>SV)) { sk = k; SV = V; } if ((j1!=j) || Stop) { // end of horizontal section AlgnS[sk] = S[j-1]; sk = -1; } // treat vertical section if ((tk<0) || (V>TV)) { tk = k; TV = V; } if ((i1!=i) || Stop) { // end of vertical section AlgnT[tk] = T[i-1]; tk = -1; } i = i1; j = j1; k++; } if (!StopAtZero) { // 4. Finish the last horizontal section sk = k; while (j>0) AlgnS[k++] = S[--j]; // 5. Finish the last vertical section while (i>0) AlgnT[sk++] = T[--i]; k = IMax ( k,sk ); } // 6. Put the termination character AlgnLen = k; // 7. Reverse the strings i = 0; j = k-1; if (StopAtZero) { // should work only for local alignment while ((j>0) && ((AlgnS[j]==Space) || (AlgnT[j]==Space))) j--; AlgnLen = j+1; } while (j>i) { C = AlgnS[i]; AlgnS[i] = AlgnS[j]; AlgnS[j] = C; C = AlgnT[i]; AlgnT[i] = AlgnT[j]; AlgnT[j] = C; i++; j--; } // 8. Filter out parasite spaces k = 0; i = 0; while (ki); } void CAlignment1::AdjustEnds ( ivector S, ivector T, int J, int I ) { int is,it; is = J; it = I; while ((is0.0) && (a>0.0)) return s/a; return 0.0; } void CAlignment1::OutputResults ( RCFile f, ivector S, int lenS, ivector T, int lenT ) { int k,l,n; char P[10]; if ((!AlgnS) || (!AlgnT)) { f.LF(); f.WriteLine ( pstr(" NO ALIGNMENT HAS BEEN DONE.") ); f.shut(); return; } f.LF(); f.WriteLine ( pstr(" ======== INPUT DATA") ); f.LF(); f.WriteLine ( pstr(" String S:") ); f.Write ( pstr(" ") ); l = 1; k = 0; while (k=WrapPeriod) { f.LF(); f.Write ( pstr(" ") ); l = 1; } } f.LF(); f.LF(); f.WriteLine ( pstr(" String T:") ); f.Write ( pstr(" ") ); l = 1; k = 0; while (k=WrapPeriod) { f.LF(); f.Write ( pstr(" ") ); l = 1; } } f.LF(); f.LF(); f.WriteParameter ( pstr(" Score equal") ,SEq ,20,10 ); f.WriteParameter ( pstr(" Score unequal"),SNEq,20,10 ); f.LF(); f.WriteParameter ( pstr(" Gap weight") ,Wg ,20,10 ); f.WriteParameter ( pstr(" Space weight") ,Ws ,20,10 ); f.LF(); f.LF(); f.Write ( pstr(" ======== RESULT OF ") ); switch (AlignKey) { default : case ALIGN_GLOBAL : f.Write ( pstr("GLOBAL") ); break; case ALIGN_LOCAL : f.Write ( pstr("LOCAL") ); break; case ALIGN_GLOBLOC : f.Write ( pstr("GLOBAL/LOCAL") ); break; case ALIGN_FREEENDS : f.Write ( pstr("FREE-ENDS") ); } f.WriteLine ( pstr(" ALIGNMENT") ); f.LF(); if (AlignKey==ALIGN_GLOBLOC) { f.WriteLine ( pstr(" End gaps in T-string were not penalized") ); f.LF(); } f.WriteParameter ( pstr(" Highest score achieved:"), VAchieved,26,10 ); f.LF(); f.WriteLine ( pstr(" Aligned S (upper string) and T " "(lower string):") ); f.LF(); k = 0; n = 0; l = 1; f.Write ( pstr(" ") ); while (k=WrapPeriod) || (!AlgnS[k])) { f.LF(); f.Write ( pstr(" ") ); l = 1; while ((n // ~~~~~~~~~ // **** Project : MacroMolecular Data Base (MMDB) // ~~~~~~~~~ // **** Classes : CXMLObject // ~~~~~~~~~ // // (C) E. Krissinel 2000-2010 // // ================================================================= // #ifndef __STDLIB_H #include #endif #ifndef __STRING_H #include #endif #ifndef __MMDB_XML__ #include "mmdb_xml.h" #endif // ====================== CXMLObject ========================== CXMLObject::CXMLObject() : CStream() { InitXMLObject(); } CXMLObject::CXMLObject ( cpstr Tag ) : CStream() { InitXMLObject(); SetTag ( Tag ); } CXMLObject::CXMLObject ( cpstr Tag, cpstr Data ) : CStream() { InitXMLObject(); SetTag ( Tag ); SetData ( Data ); } CXMLObject::CXMLObject ( cpstr Tag, realtype V, int length ) : CStream() { InitXMLObject(); SetTag ( Tag ); SetData ( V,length ); } CXMLObject::CXMLObject ( cpstr Tag, int iV, int length ) : CStream() { InitXMLObject(); SetTag ( Tag ); SetData ( iV,length ); } CXMLObject::CXMLObject ( cpstr Tag, Boolean bV ) : CStream() { InitXMLObject(); SetTag ( Tag ); SetData ( bV ); } CXMLObject::CXMLObject ( cpstr Tag, PCXMLObject XMLObject ) : CStream() { InitXMLObject(); SetTag ( Tag ); AddObject ( XMLObject ); } CXMLObject::CXMLObject ( RPCStream Object ) : CStream(Object) { InitXMLObject(); } CXMLObject::~CXMLObject() { FreeMemory(); } void CXMLObject::InitXMLObject() { parent = NULL; objTag = NULL; objData = NULL; nObjects = 0; nAlloc = 0; object = NULL; nAttributes = 0; nAttrAlloc = 0; attr_name = NULL; attr_value = NULL; } void CXMLObject::FreeMemory() { int i; if (objTag) delete[] objTag; if (objData) delete[] objData; objTag = NULL; objData = NULL; if (object) { for (i=0;i=nAttrAlloc) { nAttrAlloc = nAttributes + 10; GetVectorMemory ( an,nAttrAlloc,0 ); GetVectorMemory ( av,nAttrAlloc,0 ); for (i=0;iGetCategoryID()==MMCIF_Loop) return AddMMCIFLoop ( PCMMCIFLoop(mmCIFCat) ); if (mmCIFCat->GetCategoryID()==MMCIF_Struct) return AddMMCIFStruct ( PCMMCIFStruct(mmCIFCat) ); return -1; } pstr getCCIFTag ( pstr & ccifTag, cpstr Tag ) { if (Tag[0]=='_') return CreateCopCat ( ccifTag,pstr("ccif") ,Tag ); else return CreateCopCat ( ccifTag,pstr("ccif_"),Tag ); } int CXMLObject::AddMMCIFStruct ( PCMMCIFStruct mmCIFStruct ) { PCXMLObject XMLObject1,XMLObject2; pstr SName,Tag,Field, ccifTag; int nTags,i,k; XMLObject1 = this; ccifTag = NULL; SName = mmCIFStruct->GetCategoryName(); if (SName) { if (SName[0]!=char(1)) XMLObject1 = new CXMLObject ( getCCIFTag(ccifTag,SName) ); } k = 0; nTags = mmCIFStruct->GetNofTags(); for (i=0;iGetTag ( i ); if (Tag) { XMLObject2 = new CXMLObject ( getCCIFTag(ccifTag,Tag) ); Field = mmCIFStruct->GetField ( i ); if (Field) { if (Field[0]!=char(2)) XMLObject2->SetData ( Field ); else XMLObject2->SetData ( &(Field[1]) ); } XMLObject1->AddObject ( XMLObject2 ); k++; } } if (SName) { if (SName[0]!=char(1)) AddObject ( XMLObject1 ); } if (ccifTag) delete[] ccifTag; return k; } int CXMLObject::AddMMCIFLoop ( PCMMCIFLoop mmCIFLoop ) { PCXMLObject XMLObject1,XMLObject2,XMLObject3; pstr SName,Tag,Field,ccifTag; int nTags,nRows,i,j,k; XMLObject1 = this; ccifTag = NULL; SName = mmCIFLoop->GetCategoryName(); if (SName) { if (SName[0]!=char(1)) XMLObject1 = new CXMLObject ( getCCIFTag(ccifTag,SName) ); } k = 0; nTags = mmCIFLoop->GetNofTags (); nRows = mmCIFLoop->GetLoopLength(); for (i=0;iGetTag ( j ); if (Tag) { XMLObject3 = new CXMLObject ( getCCIFTag(ccifTag,Tag) ); Field = mmCIFLoop->GetField ( i,j ); if (Field) { if (Field[0]!=char(2)) XMLObject3->SetData ( Field ); else XMLObject3->SetData ( &(Field[1]) ); } XMLObject2->AddObject ( XMLObject3 ); k++; } } XMLObject1->AddObject ( XMLObject2 ); } if (SName) { if (SName[0]!=char(1)) AddObject ( XMLObject1 ); } if (ccifTag) delete[] ccifTag; return k; } int CXMLObject::AddMMCIFData ( PCMMCIFData mmCIFData ) { PCMMCIFCategory mmCIFCat; int nCats,i,k,n; nCats = mmCIFData->GetNumberOfCategories(); k = 0; n = 0; for (i=0;(i=0);i++) { mmCIFCat = mmCIFData->GetCategory ( i ); if (mmCIFCat) { if (mmCIFCat->GetCategoryID()==MMCIF_Loop) n = AddMMCIFLoop ( PCMMCIFLoop(mmCIFCat) ); else if (mmCIFCat->GetCategoryID()==MMCIF_Struct) n = AddMMCIFStruct ( PCMMCIFStruct(mmCIFCat) ); else n = -1; if (n>=0) k += n; } } if (n<0) return -(k+1); return k; } pstr CXMLObject::GetData ( cpstr Tag, int objNo ) { PCXMLObject XMLObject; XMLObject = GetObject ( Tag,objNo ); if (XMLObject) return XMLObject->objData; return NULL; } int CXMLObject::GetData ( pstr & Data, cpstr Tag, int objNo ) { PCXMLObject XMLObject; XMLObject = GetObject ( Tag,objNo ); if (XMLObject) { Data = XMLObject->objData; return 0; } else { Data = NULL; return 1; } } int CXMLObject::GetData ( realtype & V, cpstr Tag, int objNo ) { int rc; pstr d,p; rc = GetData ( d,Tag,objNo ); if (d) { V = strtod(d,&p); if ((V==0.0) && (p==d)) rc = 2; else rc = 0; } else if (!rc) rc = -1; return rc; } int CXMLObject::GetData ( int & iV, cpstr Tag, int objNo ) { int rc; pstr d,p; rc = GetData ( d,Tag,objNo ); if (d) { iV = mround(strtod(d,&p)); if ((iV==0) && (p==d)) rc = 2; else rc = 0; } else if (!rc) rc = -1; return rc; } int CXMLObject::GetData ( Boolean & bV, cpstr Tag, int objNo ) { int rc; pstr d; rc = GetData ( d,Tag,objNo ); if (d) { if (!strcasecmp(d,"Yes")) bV = True; else { bV = False; if (strcasecmp(d,"No")) rc = 2; } } else if (!rc) rc = -1; return rc; } PCXMLObject CXMLObject::GetObject ( cpstr Tag, int objNo ) { // allow for "tag1>tag2>tag3>..." PCXMLObject XMLObject; int i,j,k,l; pstr p,p1; XMLObject = this; if (Tag) { p = pstr(Tag); do { p1 = p; l = 0; while (*p1 && (*p1!='>')) { p1++; l++; } if (l>0) { k = -1; j = 0; for (i=0;(inObjects) && (k<0);i++) if (XMLObject->object[i]) { if (!strncmp(XMLObject->object[i]->objTag,p,l)) { j++; if (j==objNo) k = i; } } if (k<0) { XMLObject = NULL; l = 0; } else { XMLObject = XMLObject->object[k]; if (*p1) p = p1 + 1; else l = 0; } } } while (l>0); } return XMLObject; } PCXMLObject CXMLObject::GetFirstObject() { if (nObjects>0) return object[0]; return NULL; } PCXMLObject CXMLObject::GetLastObject() { if (nObjects>0) return object[nObjects-1]; return NULL; } PCXMLObject CXMLObject::GetObject ( int objectNo ) { if ((0<=objectNo) && (objectNo=nAlloc) { nAlloc += lenInc; obj1 = new PCXMLObject[nAlloc]; for (i=0;iSetParent ( this ); nObjects++; } int CXMLObject::WriteObject ( cpstr FName, int pos, int indent ) { CFile f; f.assign ( FName,True ); if (f.rewrite()) { WriteObject ( f,pos,indent ); f.shut(); return 0; } return 1; } void CXMLObject::WriteObject ( RCFile f, int pos, int indent ) { int i,pos1,lm,rm,tl; pstr indstr,p,p1,q; Boolean sngline; if (objTag) { pos1 = pos + indent; indstr = new char[pos1+1]; for (i=0;i") ); delete[] indstr; return; } f.Write ( pstr(">") ); sngline = False; if (objData) { rm = 72; // right margin lm = IMin ( pos1,36 ); // left margin tl = strlen(objTag); if ((pos+tl+2+(int)strlen(objData)WriteObject ( f,pos+indent,indent ); if (!sngline) f.Write ( indstr ); f.Write ( pstr("") ); delete[] indstr; } } int CXMLObject::ReadObject ( cpstr FName ) { CFile f; char S[500]; int i,rc; f.assign ( FName,True ); if (f.reset(True)) { S[0] = char(0); i = 0; rc = ReadObject ( f,S,i,sizeof(S) ); f.shut(); } else rc = XMLR_NoFile; if (rc) FreeMemory(); return rc; } int CXMLObject::ReadObject ( RCFile f, pstr S, int & pos, int slen ) { PCXMLObject XMLObject; pstr S1; int k,k1,k2,rc; Boolean Done; FreeMemory(); rc = XMLR_Ok; k1 = -1; k2 = -1; while ((!f.FileEnd()) && (k1<0)) { k = strlen(S); while ((pos // constructions pos++; else if (S[pos+1]!='<') k1 = pos; else pos += 2; } else pos++; if (k1>=0) { k2 = -1; while ((pos') { if (S[pos+1]!='>') k2 = pos; else pos += 2; } else pos++; if (k2<0) rc = XMLR_BrokenTag; } if (k1<0) { f.ReadLine ( S,slen ); pos = 0; } } if (k1<0) return XMLR_NoTag; if (rc!=XMLR_Ok) return rc; pos++; if (S[k2-1]=='/') { // S[k2-1] = char(0); CreateCopy ( objTag,&(S[k1+1]) ); return XMLR_Ok; } S[k2] = char(0); CreateCopy ( objTag,&(S[k1+1]) ); S[k2] = '>'; S1 = new char[slen+1]; Done = False; while ((!f.FileEnd()) && (!Done)) { k = strlen(S); while ((pos=0) S[k2] = char(0); strcpy_des ( S1,&(S[k1]) ); if (S1[0]) { if (objData) CreateConcat ( objData,pstr(" "),S1 ); else CreateConcat ( objData,S1 ); } if (k2>=0) { S[k2] = '<'; if (S[k2+1]!='/') { XMLObject = new CXMLObject(); AddObject ( XMLObject ); rc = XMLObject->ReadObject ( f,S,pos,slen ); Done = (rc!=XMLR_Ok); } else { Done = True; k1 = k2+2; k2 = -1; while ((pos') { if (S[pos+1]!='>') k2 = pos; else pos += 2; } else pos++; if (k2<0) rc = XMLR_BrokenTag; else { S[k2] = char(0); if (strcmp(objTag,&(S[k1]))) rc = XMLR_UnclosedTag; else pos++; } } } } if (!Done) { f.ReadLine ( S,slen ); pos = 0; } } delete[] S1; // this keeps pairs instead of replacing them for // on output if ((!objData) && (nObjects<=0)) CreateCopy ( objData,pstr("") ); if (rc!=XMLR_Ok) FreeMemory(); return rc; } void CXMLObject::Copy ( PCXMLObject XMLObject ) { int i; FreeMemory(); CreateCopy ( objTag ,XMLObject->objTag ); CreateCopy ( objData,XMLObject->objData ); nObjects = XMLObject->nObjects; nAlloc = nObjects; if (nObjects>0) { object = new PCXMLObject[nObjects]; for (i=0;iobject[i]) { object[i] = new CXMLObject(); object[i]->Copy ( XMLObject->object[i] ); } else object[i] = NULL; } nAttributes = XMLObject->nAttributes; nAttrAlloc = nAttributes; if (nAttributes>0) { GetVectorMemory ( attr_name ,nAttrAlloc,0 ); GetVectorMemory ( attr_value,nAttrAlloc,0 ); for (i=0;iattr_name [i] ); CreateCopy ( attr_value[i],XMLObject->attr_value[i] ); } } } void CXMLObject::write ( RCFile f ) { int i; f.CreateWrite ( objTag ); f.CreateWrite ( objData ); f.WriteInt ( &nObjects ); for (i=0;i0) { object = new PCXMLObject[nObjects]; for (i=0;i0) { GetVectorMemory ( attr_name ,nAttrAlloc,0 ); GetVectorMemory ( attr_value,nAttrAlloc,0 ); for (i=0;iGetDataName(); if (dataName) { if (dataName[0]) XMLObject = new CXMLObject ( dataName ); } if (!XMLObject) XMLObject = new CXMLObject ( pstr("no_data_name") ); k = XMLObject->AddMMCIFData ( mmCIFData ); if (rc) *rc = k; } return XMLObject; } PCXMLObject mmCIF2XML ( cpstr XMLName, PCMMCIFFile mmCIFFile, int * rc ) { PCXMLObject XMLObject1,XMLObject2; PCMMCIFData mmCIFData; int nData,i,k,rc1; XMLObject1 = new CXMLObject ( XMLName ); if (rc) *rc = -1; if (mmCIFFile) { nData = mmCIFFile->GetNofData(); k = 0; rc1 = 0; for (i=0;(i=0);i++) { mmCIFData = mmCIFFile->GetCIFData ( i ); if (mmCIFData) { XMLObject2 = mmCIF2XML ( mmCIFData,&rc1 ); if (XMLObject2) { if (rc1>=0) { XMLObject1->AddObject ( XMLObject2 ); k += rc1; } else delete XMLObject2; } } } if (rc1<0) { delete XMLObject1; if (rc) *rc = -2; } else if (rc) *rc = k; } return XMLObject1; } mmdb-1.25.5/mmdb/mmdb_sbase0.cpp0000775000175000017500000023446011736610510013261 00000000000000// $Id: mmdb_sbase0.cpp,v 1.19 2012/01/26 17:52:21 ekr Exp $ // ================================================================= // // CCP4 Coordinate Library: support of coordinate-related // functionality in protein crystallography applications. // // Copyright (C) Eugene Krissinel 2000-2008. // // This library is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // // ================================================================= // // 29.01.10 <-- Date of Last Modification. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ----------------------------------------------------------------- // // **** Module : mmdb_sbase0 // ~~~~~~~~~ // **** Classes : CSBase0 ( structure base manager 0 ) // ~~~~~~~~~ CSBAtom ( SB atom class ) // CSBBond ( SB bond class ) // CSBStructure ( SB structure (monomer) class ) // CSBIndex ( SB index class ) // // (C) E. Krissinel 2000-2010 // // ================================================================= // #ifndef __STDLIB_H #include #endif #ifndef __STRING_H #include #endif #ifndef __LinAlg__ #include "linalg_.h" #endif #ifndef __MMDB_SBase0__ #include "mmdb_sbase0.h" #endif #ifndef __MMDB_Tables__ #include "mmdb_tables.h" #endif // ====================== SB Atom Class ========================= CSBAtom::CSBAtom() : CStream() { SBAtomInit(); } CSBAtom::CSBAtom ( RPCStream Object ) : CStream(Object) { SBAtomInit(); } CSBAtom::~CSBAtom() {} void CSBAtom::SBAtomInit() { sca_name [0] = char(0); pdb_name [0] = char(0); old_pdb_name[0] = char(0); element [0] = char(0); energyType [0] = char(0); x = -MaxReal; y = -MaxReal; z = -MaxReal; x_esd = 0.0; y_esd = 0.0; z_esd = 0.0; ccp4_charge = 0.0; // atom charge from ccp4 libs sca_charge = 0.0; // formal atom charge (MSD) partial_charge = 0.0; // partial atom charge (MSD) vdw_radius = 0.0; vdwh_radius = 0.0; ion_radius = 0.0; valency = 0; chirality = 'N'; leaving = 'N'; hb_type = 'N'; } void CSBAtom::Copy ( PCSBAtom A ) { strcpy ( sca_name ,A->sca_name ); strcpy ( pdb_name ,A->pdb_name ); strcpy ( old_pdb_name,A->old_pdb_name ); strcpy ( element ,A->element ); strcpy ( energyType ,A->energyType ); x = A->x; y = A->y; z = A->z; x_esd = A->x_esd; y_esd = A->y_esd; z_esd = A->z_esd; ccp4_charge = A->ccp4_charge; sca_charge = A->sca_charge; partial_charge = A->partial_charge; vdw_radius = A->vdw_radius; vdwh_radius = A->vdwh_radius; ion_radius = A->ion_radius; valency = A->valency; chirality = A->chirality; leaving = A->leaving; hb_type = A->hb_type; } void CSBAtom::makeCAtom ( RPCAtom a ) { if (!a) a = newCAtom(); a->SetAtomName ( 0,0,pdb_name,"","",element ); a->SetCharge ( ccp4_charge ); a->SetCoordinates ( x,y,z,1.0,0.0 ); strcpy ( a->energyType,energyType ); a->sigOcc = -1.0; // signal that atom was added from SBase } PCAtom CSBAtom::makeCAtom() { PCAtom a; a = newCAtom(); a->SetAtomName ( 0,0,pdb_name,"","",element ); a->SetCharge ( ccp4_charge ); a->SetCoordinates ( x,y,z,1.0,0.0 ); strcpy ( a->energyType,energyType ); a->sigOcc = -1.0; // signal that atom was added from SBase return a; } void CSBAtom::write ( RCFile f ) { int Version=5; f.WriteInt ( &Version ); f.WriteFile ( sca_name ,sizeof(sca_name) ); f.WriteFile ( pdb_name ,sizeof(pdb_name) ); f.WriteFile ( old_pdb_name,sizeof(old_pdb_name) ); f.WriteFile ( element ,sizeof(element) ); f.WriteFile ( energyType ,sizeof(energyType) ); f.WriteReal ( &x ); f.WriteReal ( &y ); f.WriteReal ( &z ); f.WriteReal ( &x_esd ); f.WriteReal ( &y_esd ); f.WriteReal ( &z_esd ); f.WriteReal ( &ccp4_charge ); f.WriteReal ( &sca_charge ); f.WriteReal ( &partial_charge ); f.WriteReal ( &vdw_radius ); f.WriteReal ( &vdwh_radius ); f.WriteReal ( &ion_radius ); f.WriteInt ( &valency ); f.WriteFile ( &chirality,sizeof(chirality) ); f.WriteFile ( &leaving ,sizeof(leaving) ); f.WriteFile ( &hb_type ,sizeof(hb_type) ); } void CSBAtom::read ( RCFile f ) { int Version; f.ReadInt ( &Version ); f.ReadFile ( sca_name ,sizeof(sca_name) ); f.ReadFile ( pdb_name ,sizeof(pdb_name) ); if (Version>4) f.ReadFile ( old_pdb_name,sizeof(old_pdb_name) ); else strcpy ( old_pdb_name,pdb_name ); f.ReadFile ( element ,sizeof(element) ); f.ReadFile ( energyType,sizeof(energyType) ); f.ReadReal ( &x ); f.ReadReal ( &y ); f.ReadReal ( &z ); f.ReadReal ( &x_esd ); f.ReadReal ( &y_esd ); f.ReadReal ( &z_esd ); if (Version>2) f.ReadReal ( &ccp4_charge ); if (Version>3) { f.ReadReal ( &sca_charge ); f.ReadReal ( &partial_charge ); } if (Version>1) { f.ReadReal ( &vdw_radius ); f.ReadReal ( &vdwh_radius ); f.ReadReal ( &ion_radius ); f.ReadInt ( &valency ); } f.ReadFile ( &chirality,sizeof(chirality) ); f.ReadFile ( &leaving ,sizeof(leaving) ); if (Version>1) f.ReadFile ( &hb_type,sizeof(hb_type) ); } MakeStreamFunctions(CSBAtom) // ======================= SB Bond Class ======================= CSBBond::CSBBond() : CStream() { SBBondInit(); } CSBBond::CSBBond ( RPCStream Object ) : CStream(Object) { SBBondInit(); } CSBBond::~CSBBond() {} void CSBBond::SBBondInit() { atom1 = -1; atom2 = -1; order = BOND_SINGLE; length = 0.0; length_esd = 0.0; } void CSBBond::SetBond ( int at1, int at2, int ord ) { atom1 = at1; atom2 = at2; order = ord; } void CSBBond::Copy ( PCSBBond B ) { atom1 = B->atom1; atom2 = B->atom2; order = B->order; length = B->length; length_esd = B->length_esd; } void CSBBond::write ( RCFile f ) { int Version=1; f.WriteInt ( &Version ); f.WriteInt ( &atom1 ); f.WriteInt ( &atom2 ); f.WriteInt ( &order ); f.WriteReal ( &length ); f.WriteReal ( &length_esd ); } void CSBBond::read ( RCFile f ) { int Version; f.ReadInt ( &Version ); f.ReadInt ( &atom1 ); f.ReadInt ( &atom2 ); f.ReadInt ( &order ); f.ReadReal ( &length ); f.ReadReal ( &length_esd ); } MakeStreamFunctions(CSBBond) // ======================= SB Angle Class ===================== CSBAngle::CSBAngle() : CStream() { SBAngleInit(); } CSBAngle::CSBAngle ( RPCStream Object ) : CStream(Object) { SBAngleInit(); } CSBAngle::~CSBAngle() {} void CSBAngle::SBAngleInit() { atom1 = -1; atom2 = -1; atom3 = -1; angle = 0.0; angle_esd = 0.0; } void CSBAngle::Copy ( PCSBAngle G ) { atom1 = G->atom1; atom2 = G->atom2; atom3 = G->atom3; angle = G->angle; angle_esd = G->angle_esd; } void CSBAngle::write ( RCFile f ) { int Version=1; f.WriteInt ( &Version ); f.WriteInt ( &atom1 ); f.WriteInt ( &atom2 ); f.WriteInt ( &atom3 ); f.WriteReal ( &angle ); f.WriteReal ( &angle_esd ); } void CSBAngle::read ( RCFile f ) { int Version; f.ReadInt ( &Version ); f.ReadInt ( &atom1 ); f.ReadInt ( &atom2 ); f.ReadInt ( &atom3 ); f.ReadReal ( &angle ); f.ReadReal ( &angle_esd ); } MakeStreamFunctions(CSBAngle) // ====================== SB Torsion Class =================== CSBTorsion::CSBTorsion() : CStream() { SBTorsionInit(); } CSBTorsion::CSBTorsion ( RPCStream Object ) : CStream(Object) { SBTorsionInit(); } CSBTorsion::~CSBTorsion() {} void CSBTorsion::SBTorsionInit() { atom1 = -1; atom2 = -1; atom3 = -1; atom4 = -1; torsion = 0.0; torsion_esd = 0.0; } void CSBTorsion::Copy ( PCSBTorsion T ) { atom1 = T->atom1; atom2 = T->atom2; atom3 = T->atom3; atom4 = T->atom4; torsion = T->torsion; torsion_esd = T->torsion_esd; } void CSBTorsion::write ( RCFile f ) { int Version=1; f.WriteInt ( &Version ); f.WriteInt ( &atom1 ); f.WriteInt ( &atom2 ); f.WriteInt ( &atom3 ); f.WriteInt ( &atom4 ); f.WriteReal ( &torsion ); f.WriteReal ( &torsion_esd ); } void CSBTorsion::read ( RCFile f ) { int Version; f.ReadInt ( &Version ); f.ReadInt ( &atom1 ); f.ReadInt ( &atom2 ); f.ReadInt ( &atom3 ); f.ReadInt ( &atom4 ); f.ReadReal ( &torsion ); f.ReadReal ( &torsion_esd ); } MakeStreamFunctions(CSBTorsion) // ==================== Structure Class ========================= CSBStructure::CSBStructure() : CStream() { SBStructureInit(); } CSBStructure::CSBStructure ( RPCStream Object ) : CStream(Object) { SBStructureInit(); } CSBStructure::~CSBStructure() { FreeMemory(); } void CSBStructure::Reset() { FreeMemory(); SBStructureInit(); } void CSBStructure::FreeMemory() { int i; if (Formula) delete[] Formula; if (Name) delete[] Name; if (Synonym) delete[] Synonym; if (Charge) delete[] Charge; Formula = NULL; Name = NULL; Synonym = NULL; Charge = NULL; FreeVectorMemory ( leavingAtom,0 ); FreeVectorMemory ( bondedAtom ,0 ); nLeavingAtoms = 0; for (i=0;i=nAAlloc) { nAAlloc += 50; Atom1 = new PCSBAtom[nAAlloc]; for (i=0;i=nBAlloc) { nBAlloc += 50; Bond1 = new PCSBBond[nBAlloc]; for (i=0;ileaving=='Y') nLeavingAtoms++; if (nLeavingAtoms>0) { GetVectorMemory ( leavingAtom,nLeavingAtoms,0 ); GetVectorMemory ( bondedAtom ,nLeavingAtoms,0 ); j = 0; for (i=0;ileaving=='Y') { leavingAtom[j] = i+1; bondedAtom [j] = 0; j++; } for (i=0;iatom1) && (strcmp(Atom[Bond[j]->atom2-1]->element," H"))) bondedAtom[i] = Bond[j]->atom2; else if ((leavingAtom[i]==Bond[j]->atom2) && (strcmp(Atom[Bond[j]->atom1-1]->element," H"))) bondedAtom[i] = Bond[j]->atom1; } } } void CSBStructure::AddAngle ( PCSBAngle angle ) { PPCSBAngle Angle1; int i; if (nAngles>=nGAlloc) { nGAlloc += 50; Angle1 = new PCSBAngle[nGAlloc]; for (i=0;i=nTAlloc) { nTAlloc += 50; Torsion1 = new PCSBTorsion[nTAlloc]; for (i=0;ienergyType[0] = char(0); } int CSBStructure::SetEnergyType ( cpstr sca_name, cpstr energyType, realtype partial_charge ) { int n; n = GetAtomNo ( sca_name ); if (n>0) { strcpy ( Atom[n-1]->energyType,energyType ); Atom[n-1]->partial_charge = partial_charge; } return n; } int CSBStructure::GetAtomNo ( cpstr sca_name ) { int n,i; n = 0; for (i=0;(isca_name)) n = i+1; } return n; } int CSBStructure::GetAtomNo_nss ( cpstr sca_name ) { // disregards leading and trailing spaces AtomName name_0; AtomName name_i; int n,i; strcpy_css ( name_0,sca_name ); // printf ( " name_0 = '%s'\n",name_0 ); n = 0; for (i=0;(isca_name ); // printf ( " name_i = '%s'\n",name_i ); if (!strcmp(name_0,name_i)) n = i+1; } return n; } PCSBAtom CSBStructure::GetAtom ( cpstr sca_name ) { int n; n = GetAtomNo ( sca_name ); if (n>0) return Atom[n-1]; else return NULL; } void CSBStructure::GetAtomTable ( PPCAtom & atomTable, int & nOfAtoms ) { int i; nOfAtoms = nAtoms; if (nAtoms>0) { atomTable = new PCAtom[nAtoms]; for (i=0;imakeCAtom ( atomTable[i] ); } } else atomTable = NULL; } void CSBStructure::GetAtomNameMatch ( PPCAtom A, int nat, pstr altLoc, ivector anmatch ) { // GetAtomNameMatch(..) returns anmatch[i], i=0..nAtoms-1, equal // to j such that name(Atom[i])==name(A[j]). Note that atom names // are similarly aligned and space-padded in both MMDb and SBase. // If ith atom in the structue is not found in A, anmatch[i] is // set -1. // If array A contains atoms in different alternative conformations, // the the value of altLoc is interpreted as follows: // NULL - the highest occupancy atom will be taken // if all occupancies are equal then atom with // first altLoc taken // other - atoms with given altLoc are taken. If such // altLoc is not found, the function does as if // NULL value for altLoc is given. // A clean PDB file is anticipated, so that atoms with alternative // conformations are grouped together. // It is Ok to have NULL pointers in A. int i,j,k; Boolean done; for (i=0;iTer) && (!strcmp(A[j]->name,Atom[i]->pdb_name))) { k = j; // atom found // check now for altLocs j++; while ((jTer || (strcmp(A[j]->name,Atom[i]->pdb_name))); if (!done) { if (A[j]->occupancy>A[k]->occupancy) k = j; if (altLoc) { if (!strcmp(A[j]->altLoc,altLoc)) { k = j; done = True; } } } } j++; } } } j++; } anmatch[i] = k; } } int CSBStructure::CheckAtoms() { // CheckAtoms() returns -1 if there is no atoms // -2 if not all atoms are annotated // -3 if not all coordinates are set // 0 otherwise int i,rc; if (nAtoms<=0) return -1; for (i=0;ix==-MaxReal) rc = -3; return rc; } PCResidue CSBStructure::makeCResidue ( Boolean includeHydrogens, Boolean makeTer ) { PCResidue Res; int i; Res = newCResidue(); for (i=0;ipdb_name[2]),"XT")) && (includeHydrogens || strcmp(Atom[i]->element," H"))) Res->AddAtom ( Atom[i]->makeCAtom() ); } return Res; } int superpose_atoms ( mat44 & T, PPCSBAtom A1, PPCAtom A2, int nAtoms, rmatrix & A, rmatrix & U, rmatrix & V, rvector & W, rvector & RV1 ) { // Given two sets of atoms, A1 and A2, superpose_atoms(...) // calculates the rotational-translational matrix T such that // |T*A1 - A2| is minimal in least-square terms. The transfomation // superposes exactly the atoms A1[0] and A2[0]. realtype det,B; vect3 vc1,vc2; int i,j,k; // 1. Calculate the correlation matrix. The rotation will be // done around for (i=1;i<=3;i++) for (j=1;j<=3;j++) A[i][j] = 0.0; for (k=1;kx - A1[0]->x; vc1[1] = A1[k]->y - A1[0]->y; vc1[2] = A1[k]->z - A1[0]->z; vc2[0] = A2[k]->x - A2[0]->x; vc2[1] = A2[k]->y - A2[0]->y; vc2[2] = A2[k]->z - A2[0]->z; for (i=1;i<=3;i++) for (j=1;j<=3;j++) A[i][j] += vc1[j-1]*vc2[i-1]; } // 2. Calculate transformation matrix (to be applied to A1) det = A[1][1]*A[2][2]*A[3][3] + A[1][2]*A[2][3]*A[3][1] + A[2][1]*A[3][2]*A[1][3] - A[1][3]*A[2][2]*A[3][1] - A[1][1]*A[2][3]*A[3][2] - A[3][3]*A[1][2]*A[2][1]; // 2.1 SV-decompose the correlation matrix SVD ( 3,3,3,A,U,V,W,RV1,True,True,i ); if (i!=0) return SPOSEAT_SVD_Fail; // 2.2 Check for parasite inversion and fix it if found if (det<=0.0) { k = 0; B = MaxReal; for (j=1;j<=3;j++) if (W[j]x - T[0][0]*A1[0]->x - T[0][1]*A1[0]->y - T[0][2]*A1[0]->z; T[1][3] = A2[0]->y - T[1][0]*A1[0]->x - T[1][1]*A1[0]->y - T[1][2]*A1[0]->z; T[2][3] = A2[0]->z - T[2][0]*A1[0]->x - T[2][1]*A1[0]->y - T[2][2]*A1[0]->z; return SPOSEAT_Ok; } int CSBStructure::AddHydrogens ( PCResidue R ) { // // Return: // SBASE_Ok success // SBASE_EmptyResidue residue R does not contain atoms // SBASE_NoAtomsFound SBStructure does not contain atoms // SBASE_NoBonds SBStructure does not contain bonds // SBASE_NoAtomsData SBStructure is not complete // SBASE_NoSimilarity too few coomon atom names in R and SBase // entry with the same structure name // SBASE_SuperpositionFailed failed residue superposition // // NOTE1: the function does not rearranges existing atoms in the // residue, but places the hydrogens on top of them (leaving the // Ter pseudoatom, if found, on top of the list). // // NOTE2: in case of alternative locations, the first one in the // residue is chosen. // PPCAtom H; PCSBAtom sa1[10]; PCAtom sa2[10]; rmatrix D,U,V; rvector W,RV1; imatrix c; ivector A,nb; mat44 T; int i,j,k,m,n,mm,nTer,nH; // 1. Make simple checks if (nAtoms<=2) return SBASE_NoAtomsFound; if (nBonds<=0) return SBASE_NoBonds; if (R->nAtoms<=2) return SBASE_EmptyResidue; if (nAtoms==R->nAtoms) return SBASE_Ok; // 2. Map existing atoms from the residue onto a local array GetVectorMemory ( A,nAtoms,0 ); nTer = 20000; for (i=0;inAtoms) && (A[i]<0);j++) if (R->atom[j]) { if (R->atom[j]->Ter) nTer = j; else if (!strcmp(Atom[i]->pdb_name,R->atom[j]->name)) A[i] = j; // here is the place to check for altlocs } } // 3. Make bond matrix GetMatrixMemory ( c ,nAtoms,10,0,0 ); GetVectorMemory ( nb,nAtoms,0 ); for (i=0;iatom1-1; k = Bond[i]->atom2-1; c[j][nb[j]] = k; c[k][nb[k]] = j; nb[j]++; nb[k]++; } // 4. Loop over all hydrogens. Locate core atoms bonded to // hydrogen in SBStructure and superpose them with the // corresponding atoms in the residue. Using the superposition // matrix, add hydrogens to the residue. GetMatrixMemory ( D ,3,3,1,1 ); GetMatrixMemory ( U ,3,3,1,1 ); GetMatrixMemory ( V ,3,3,1,1 ); GetVectorMemory ( W ,3,1 ); GetVectorMemory ( RV1,3,1 ); H = new PCAtom[nAtoms]; nH = 0; for (i=0;ielement," H")) && (A[i]<0) && (nb[i]>0) && (Atom[i]->x>-MaxReal)) { // ith atom is a hydrogen which is not found in the residue. // Find 3+ core atoms that are most closely bonded to this one. n = c[i][0]; // core atom bonded to the hydrogen if (A[n]>=0) { sa1[0] = Atom[n]; sa2[0] = R->atom[A[n]]; mm = 1; m = 1; while ((m<3) && (mm<2)) { k = n; for (j=0;(j=0) { sa1[m] = Atom[n]; sa2[m] = R->atom[A[n]]; m++; } } mm++; } if (m>=3) { // superpose atoms and add the hydrogen to the residue k = superpose_atoms ( T,sa1,sa2,m,D,U,V,W,RV1 ); if (k==SPOSEAT_Ok) { H[nH] = Atom[i]->makeCAtom(); H[nH]->Transform ( T ); nH++; } } } } // 5. Put hydrogens into the residue for (i=0;iInsertAtom ( H[i],nTer ); nTer++; } // 6. Release memory and return if (H) delete[] H; FreeVectorMemory ( A,0 ); FreeVectorMemory ( RV1,1 ); FreeVectorMemory ( W ,1 ); FreeMatrixMemory ( V ,3,1,1 ); FreeMatrixMemory ( U ,3,1,1 ); FreeMatrixMemory ( D ,3,1,1 ); FreeVectorMemory ( nb,0 ); FreeMatrixMemory ( c ,nAtoms,0,0 ); return SBASE_Ok; } void CSBStructure::Copy ( PCSBStructure S ) { int i; FreeMemory(); strcpy ( compoundID,S->compoundID ); CreateCopy ( Formula ,S->Formula ); CreateCopy ( Name ,S->Name ); CreateCopy ( Synonym ,S->Synonym ); CreateCopy ( Charge ,S->Charge ); xyz_source = S->xyz_source; nLeavingAtoms = S->nLeavingAtoms; if (nLeavingAtoms>0) { GetVectorMemory ( leavingAtom,nLeavingAtoms,0 ); GetVectorMemory ( bondedAtom ,nLeavingAtoms,0 ); for (i=0;ileavingAtom[i]; bondedAtom [i] = S->bondedAtom [i]; } } nAtoms = S->nAtoms; nAAlloc = nAtoms; if (nAtoms>0) { Atom = new PCSBAtom[nAtoms]; for (i=0;iCopy ( S->Atom[i] ); } } nBonds = S->nBonds; nBAlloc = nBonds; if (nBonds>0) { Bond = new PCSBBond[nBonds]; for (i=0;iCopy ( S->Bond[i] ); } } nAngles = S->nAngles; nGAlloc = nAngles; if (nAngles>0) { Angle = new PCSBAngle[nAngles]; for (i=0;iCopy ( S->Angle[i] ); } } nTorsions = S->nTorsions; nTAlloc = nTorsions; if (nTorsions>0) { Torsion = new PCSBTorsion[nTorsions]; for (i=0;iCopy ( S->Torsion[i] ); } } } void CSBStructure::write ( RCFile f ) { int i,Version=1; f.WriteInt ( &Version ); f.WriteFile ( compoundID,sizeof(compoundID) ); f.CreateWrite ( Formula ); f.CreateWrite ( Name ); f.CreateWrite ( Synonym ); f.CreateWrite ( Charge ); f.WriteFile ( &xyz_source,sizeof(xyz_source) ); f.WriteInt ( &nLeavingAtoms ); for (i=0;i0) { GetVectorMemory ( leavingAtom,nLeavingAtoms,0 ); GetVectorMemory ( bondedAtom ,nLeavingAtoms,0 ); for (i=0;i0) { Atom = new PCSBAtom[nAtoms]; for (i=0;i0) { Bond = new PCSBBond[nBonds]; for (i=0;i0) { Angle = new PCSBAngle[nAngles]; for (i=0;i0) { Torsion = new PCSBTorsion[nTorsions]; for (i=0;i not loaded nXTs = 0; // total number of "XT"-atoms Comp1 = NULL; Comp2 = NULL; } int CSBIndex::MakeCompositions ( PCSBStructure SBS ) { // MakeCompositions(..) makes the compositions strings for the // given structure. // A composition string consists of records E(N), where E stands // for chemical element name, and N - for the number of atoms of this // element in the structure. The records E(N) follow in alphabetical // order of E without spaces and contain no spaces, records with N=0 // are excluded. // Comp2 differs of Comp1 only if there are leaving atoms and // represents the composition with leaving atoms taken into account. // If there is no leaving atoms, Comp2==Comp1. // The function returns the number of leaving atoms in the. // structure. char Cmp1[1000]; char Cmp2[1000]; char N[50]; ivector elem; int i,k,x,l,nl; short n0,n; nAtoms = SBS->nAtoms; nBonds = SBS->nBonds; strcpy ( Cmp1,"" ); strcpy ( Cmp2,"" ); GetVectorMemory ( elem,nAtoms,0 ); for (i=0;iAtom[i]->element ); n0 = -1; n = 0; nl = 0; for (i=0;(in0) && (elem[k]Atom[k]->leaving=='Y') l++; } nl += l; sprintf ( N,"%s(%i)",ElementName[n-1],x ); strcat ( Cmp1,N ); sprintf ( N,"%s(%i)",ElementName[n-1],x-l ); strcat ( Cmp2,N ); n0 = n; } } FreeVectorMemory ( elem,0 ); CreateCopy ( Comp1,Cmp1 ); CreateCopy ( Comp2,Cmp2 ); return nl; } void CSBIndex::write ( RCFile f ) { int Version=1; f.WriteInt ( &Version ); f.WriteFile ( compoundID,sizeof(compoundID) ); f.WriteInt ( &nAtoms ); f.WriteInt ( &nBonds ); f.WriteInt ( &fGraphPos ); f.WriteInt ( &fStructPos ); f.WriteInt ( &nXTs ); f.CreateWrite ( Comp1 ); f.CreateWrite ( Comp2 ); } void CSBIndex::read ( RCFile f ) { int Version; f.ReadInt ( &Version ); f.ReadFile ( compoundID,sizeof(compoundID) ); f.ReadInt ( &nAtoms ); f.ReadInt ( &nBonds ); f.ReadInt ( &fGraphPos ); f.ReadInt ( &fStructPos ); f.ReadInt ( &nXTs ); f.CreateRead ( Comp1 ); f.CreateRead ( Comp2 ); } MakeStreamFunctions(CSBIndex) // ========================= CSBase0 ============================ CSBase0::CSBase0() { InitSBase0(); } CSBase0::~CSBase0() { FreeMemory0(); } void CSBase0::InitSBase0() { dirpath = NULL; Index = NULL; nStructures = 0; nIAlloc = 0; nLoad = 0; nLAlloc = 0; ldGraph = NULL; ldStructure = NULL; } void CSBase0::FreeMemory0() { int i; if (dirpath) delete[] dirpath; dirpath = NULL; if (Index) { for (i=0;i0) { if (dirpath[i-1]!='/') strcat ( dirpath,"/" ); } } S = NULL; f.assign ( GetPath(S,sbIndexFile),False,True ); if (S) delete[] S; if (f.reset(True)) { while ((!f.FileEnd()) && f.Success()) { if (nStructures>=nIAlloc) { nIAlloc += 5000; Index1 = new PCSBIndex[nIAlloc]; for (i=0;iloadPos>=0) RC = SBASE_AlreadyLoaded; else { structFile = GetStructFile(); if (structFile) { structFile->seek ( Index[structNo]->fStructPos ); StreamRead ( *structFile,SBS ); structFile->shut (); delete structFile; if (!SBS) RC = SBASE_ReadError; } else RC = SBASE_FileNotFound; } if (RC==SBASE_Ok) { graphFile = GetGraphFile(); if (graphFile) { graphFile->seek ( Index[structNo]->fGraphPos ); StreamRead ( *graphFile,G ); graphFile->shut (); if (!G) RC = SBASE_ReadError; delete graphFile; } else RC = SBASE_FileNotFound; } } else RC = SBASE_StructNotFound; if (RC==SBASE_Ok) { k = -1; for (i=0;(iloadPos = k; } else { if (SBS) delete SBS; if (G) delete G; } return RC; } int CSBase0::UnloadStructure ( cpstr compoundID ) { // UnloadStructure(..) deletes strtucture from RAM and releases // its memory. The structure is then accessible through a normal // way from *.sbase files, which is slower. int structNo,ldPos; structNo = GetStructNo ( compoundID ); if (structNo==SBASE_StructNotFound) return structNo; else { ldPos = Index[structNo]->loadPos; if (ldPos<0) return SBASE_AlreadyUnloaded; if (ldStructure[ldPos]) { delete ldStructure[ldPos]; ldStructure[ldPos] = NULL; } if (ldGraph[ldPos]) { delete ldGraph[ldPos]; ldGraph[ldPos] = NULL; } Index[structNo]->loadPos = -1; } return SBASE_Ok; } int MakeChirInd ( char chirality ) { if (chirality=='S') return -1; if (chirality=='R') return +1; return 0; } int MakeElementType ( int ElType, int Chirality, Boolean Cflag ) { if (Cflag) { if (Chirality<0) return ElType | CHIRAL_LEFT; if (Chirality>0) return ElType | CHIRAL_RIGHT; } return ElType; } int MakeElementType ( int ElType, char chirality, Boolean Cflag ) { if (Cflag) { if (chirality=='S') return ElType | CHIRAL_LEFT; if (chirality=='R') return ElType | CHIRAL_RIGHT; } return ElType; } int CSBase0::GetStructNo ( cpstr compoundID ) { int l1,l2,l,k; char id[20]; strcpy_css ( id,compoundID ); k = -1; if (nStructures<=3) { for (l=0;(lcompoundID,id)) k = l; if (k>=0) return k; return SBASE_StructNotFound; } l = 0; l1 = 0; l2 = nStructures-1; while (l1compoundID,id ); if (k<0) l1 = l; else if (k>0) l2 = l; else { l1 = l; l2 = l; } } if (k==0) return l; else if (l==l1) { if (!strcasecmp(Index[l2]->compoundID,id)) return l2; } else if (l==l2) { if (!strcasecmp(Index[l1]->compoundID,id)) return l1; } return SBASE_StructNotFound; } PCFile CSBase0::GetStructFile() { PCFile structFile; pstr S; structFile = new CFile(); S = NULL; structFile->assign ( GetPath(S,sbStructFile),False,True ); if (S) delete[] S; if (!structFile->reset(True)) { delete structFile; structFile = NULL; } return structFile; } PCFile CSBase0::GetGraphFile() { PCFile graphFile; pstr S; graphFile = new CFile(); S = NULL; graphFile->assign ( GetPath(S,sbGraphFile),False,True ); if (S) delete[] S; if (!graphFile->reset(True)) { delete graphFile; graphFile = NULL; } return graphFile; } PCSBStructure CSBase0::GetStructure ( cpstr compoundID ) { // GetStructure returns pointer to the monomer structure // identified by 3-letter compoundID. If such structure is not // found, the function returns NULL. // The function returns a pointer to a private copy of the // structure. Modifying it will not change data in the structural // database. The application is responsible for deallocating // the structure after use (simply use delete). // See description of CSBStructure for the explanation of // its fields. PCFile structFile; PCSBStructure SBS; int structNo; SBS = NULL; structNo = GetStructNo ( compoundID ); if (structNo!=SBASE_StructNotFound) { if (Index[structNo]->loadPos>=0) { SBS = new CSBStructure(); SBS->Copy ( ldStructure[Index[structNo]->loadPos] ); } else { structFile = GetStructFile(); if (structFile) { structFile->seek ( Index[structNo]->fStructPos ); StreamRead ( *structFile,SBS ); structFile->shut (); delete structFile; } } } return SBS; } PCSBStructure CSBase0::GetStructure ( int structNo, PCFile structFile ) { PCFile sFile; PCSBStructure SBS; SBS = NULL; if ((0<=structNo) && (structNoloadPos>=0) { SBS = new CSBStructure(); SBS->Copy ( ldStructure[Index[structNo]->loadPos] ); } else { if (!structFile) sFile = GetStructFile(); else sFile = structFile; if (sFile) { sFile->seek ( Index[structNo]->fStructPos ); StreamRead ( *sFile,SBS ); if (!structFile) delete sFile; } } } return SBS; } PCSBStructure CSBase0::GetStructure ( cpstr compoundID, PCFile structFile ) { // Another form of GetStructure(..) uses an open structure // file, which allows to save on opening/closing file if // multiple access to SBase structures is required. PCFile sFile; PCSBStructure SBS; int structNo; SBS = NULL; structNo = GetStructNo ( compoundID ); if (structNo!=SBASE_StructNotFound) { if (Index[structNo]->loadPos>=0) { SBS = new CSBStructure(); SBS->Copy ( ldStructure[Index[structNo]->loadPos] ); } else { if (!structFile) sFile = GetStructFile(); else sFile = structFile; if (sFile) { sFile->seek ( Index[structNo]->fStructPos ); StreamRead ( *sFile,SBS ); if (!structFile) delete sFile; } } } return SBS; } PCResidue CSBase0::makeCResidue ( cpstr compoundID, PCFile structFile, Boolean includeHydrogens, Boolean makeTer ) { PCSBStructure SBS; PCResidue Res; SBS = GetStructure ( compoundID,structFile ); if (SBS) { Res = SBS->makeCResidue ( includeHydrogens,makeTer ); delete SBS; return Res; } else return NULL; } PCResidue CSBase0::makeCResidue ( int structNo, PCFile structFile, Boolean includeHydrogens, Boolean makeTer ) { PCSBStructure SBS; PCResidue Res; SBS = GetStructure ( structNo,structFile ); if (SBS) { Res = SBS->makeCResidue ( includeHydrogens,makeTer ); delete SBS; return Res; } else return NULL; } int CSBase0::GetNofAtoms ( int structNo ) { if ((0<=structNo) && (structNonAtoms; else return SBASE_StructNotFound; } int CSBase0::GetNofAtoms ( cpstr compoundID ) { int structNo; structNo = GetStructNo ( compoundID ); if (structNo!=SBASE_StructNotFound) return GetNofAtoms(structNo); else return SBASE_StructNotFound; } int CSBase0::GetGraph ( PCFile graphFile, int structNo, RPCGraph G, int Hflag ) { // GetGraph(..) retrieves data for chemical structure number structNo // (as described in Index) from graph file graphFile, then allocates // and builds the corresponding graph, which is returned in G. // If Hflag is set to 1, all hydrogens are removed from the graph. // If Hflag is set to 2, element types of atoms, to which hydrogens // are bonded, are modified with flag HYDROGEN_BOND and moved to // the end. // Returns 0 in case of success. int rc,htype; if ((structNo<0) || (structNo>=nStructures)) return SBASE_WrongIndex; rc = SBASE_Ok; if (Index[structNo]->loadPos>=0) { if (!G) G = new CGraph(); G->Copy ( ldGraph[Index[structNo]->loadPos] ); } else { graphFile->seek ( Index[structNo]->fGraphPos ); graphFile->SetSuccess(); StreamRead ( *graphFile,G ); if (!graphFile->Success()) { rc = SBASE_ReadError; if (G) delete G; G = NULL; } } if (G) { G->MakeVertexIDs(); if (Hflag>=1) { htype = getElementNo(pstr("H")); if (Hflag==2) G->HideType ( htype ); else G->ExcludeType ( htype ); } G->Build ( False ); } return rc; } int CSBase0::GetGraph ( PCFile graphFile, RPCGraph G, int Hflag ) { // GetGraph(..) retrieves data for chemical structure, which is // next in the graph file, then allocates and builds the corresponding // graph, which is returned in G. // If Hflag is set to 1, all hydrogens are removed from the graph. // If Hflag is set to 2, element types of atoms, to which hydrogens // are bonded, are modified with flag HYDROGEN_BOND and moved to // the end. // Returns 0 in case of success. int rc,htype; rc = 0; graphFile->SetSuccess(); StreamRead ( *graphFile,G ); if (!graphFile->Success()) { rc = SBASE_ReadError; if (G) delete G; G = NULL; } if (G) { G->MakeVertexIDs(); if (Hflag>=1) { htype = getElementNo(pstr("H")); if (Hflag==2) G->HideType ( htype ); else G->ExcludeType ( htype ); } G->Build ( False ); } return rc; } int CSBase0::GetGraph ( int structNo, RPCGraph G, int Hflag ) { PCFile graphFile; int htype; if ((0<=structNo) && (structNoloadPos>=0) { if (!G) G = new CGraph(); G->Copy ( ldGraph[Index[structNo]->loadPos] ); } else { graphFile = GetGraphFile(); if (graphFile) { graphFile->seek ( Index[structNo]->fGraphPos ); StreamRead ( *graphFile,G ); graphFile->shut (); delete graphFile; } else { if (G) delete G; G = NULL; return SBASE_FileNotFound; } } } else { if (G) delete G; G = NULL; return SBASE_WrongIndex; } if (G) { G->MakeVertexIDs(); if (Hflag>=1) { htype = getElementNo(pstr("H")); if (Hflag==2) G->HideType ( htype ); else G->ExcludeType ( htype ); } G->Build ( False ); } return SBASE_Ok; /* graphFile = GetGraphFile(); if (graphFile) { rc = GetGraph ( graphFile,G,Hflag ); graphFile->shut(); delete graphFile; return rc; } else { if (G) delete G; G = NULL; return SBASE_FileNotFound; } */ } int CSBase0::GetGraph ( cpstr compoundID, RPCGraph G, int Hflag ) { PCFile graphFile; int structNo,htype; structNo = GetStructNo ( compoundID ); if (structNo!=SBASE_StructNotFound) { if (Index[structNo]->loadPos>=0) { if (!G ) G = new CGraph(); G->Copy ( ldGraph[Index[structNo]->loadPos] ); } else { graphFile = GetGraphFile(); if (graphFile) { graphFile->seek ( Index[structNo]->fGraphPos ); StreamRead ( *graphFile,G ); graphFile->shut (); delete graphFile; } else { if (G) delete G; G = NULL; return SBASE_FileNotFound; } } } if (G) { G->MakeVertexIDs(); if (Hflag>=1) { htype = getElementNo(pstr("H")); if (Hflag==2) G->HideType ( htype ); else G->ExcludeType ( htype ); } G->Build ( False ); } return structNo; /* if (structNo!=SBASE_StructNotFound) { return GetGraph ( structNo,G,Hflag ); } else { if (G) delete G; G = NULL; return structNo; } */ } int CSBase0::CheckGraph ( PCGraph G, int Hflag, Boolean Cflag, int & nInStructure, int & nMatched, ivector match, int minMatchSize ) { // CheckGraph(..) checks graph G against the same-name // structure in the database. The name must be passed in // G->name as a standard 3-letter code. // If Hflag is set >= 1, all hydrogens are removed from the graph. // If Hflag is set to 2, element types of atoms, to which hydrogens // are bonded, are modified with flag HYDROGEN_BOND. // If Cflag is set to True, then chirality information is // assumed in the input graph G and it is used for the // checking. If Cflag is set to False, then chirality // information is neither assumed nor used for the checking. // If a same-name structure is found in the database, // the function returns the number of matched vertices // (nMatched) from those found in the database (nInStructure). // The correspondence between the input and database graphs // is returned in array match (it should be of sufficient // length) such that ith vertex of input graph corresponds // to the match[i]th vertex of the database graph. The // function then returns SBASE_Ok if the number of matched // vertices coincides with nInStructure and nMatched, and // the return is SBASE_CheckFail otherwise. // If a same-name structure is not found, the function // returns SBASE_StructNotFound or SBASE_FileNotFound. PCFile graphFile; PCGraphMatch U; PCGraph G1; PAtomName atName; ivector F1,F2; realtype p1,p2; int structNo,rc,j,k, nAtoms,nH, minMatch; nMatched = 0; nInStructure = 0; structNo = GetStructNo ( G->GetName() ); if (structNo==SBASE_StructNotFound) return SBASE_StructNotFound; if (Index[structNo]->loadPos<0) { graphFile = GetGraphFile(); if (!graphFile) return SBASE_FileNotFound; } else graphFile = NULL; G1 = NULL; rc = GetGraph ( graphFile,structNo,G1,Hflag ); if ((!G1) || (rc!=SBASE_Ok)) return rc; if (graphFile) { graphFile->shut(); delete graphFile; } if (!Cflag) G1->RemoveChirality(); nInStructure = G1->GetNofVertices(); if (minMatchSize>0) minMatch = minMatchSize; else minMatch = nInStructure - Index[structNo]->nXTs; U = new CGraphMatch(); U->MatchGraphs ( G,G1,minMatch ); k = U->GetNofMatches(); if (k>0) { U->GetMatch ( 0,F1,F2,nMatched,p1,p2 ); for (j=1;j<=nMatched;j++) match[F1[j]-1] = F2[j]-1; } if ((nInStructure==G->GetNofVertices()) && (nInStructure==nMatched)) { rc = SBASE_Ok; } else if (nMatched>0) { // check if atoms that were not matched are the // teminating ones ("-XT") atName = new AtomName[nInStructure*2+1]; if (Hflag>=1) nH = -1; // remove hydrogens else nH = 0; k = 1; if (GetAtNames(structNo,atName,nAtoms,nH)==SBASE_Ok) { for (j=1;j<=nMatched;j++) atName[F2[j]-1][0] = char(0); k = 0; for (j=0;(j=1) { htype = getElementNo(pstr("H")); if (Hflag==2) G->HideType ( htype ); else G->ExcludeType ( htype ); } G->Build ( False ); nInResidue = G->GetNofVertices(); if (nInResidue<=0) { rc = SBASE_NoAtomsFound; nInStructure = 0; nMatched = 0; } else rc = CheckGraph ( G,Hflag,Cflag,nInStructure,nMatched,match, minMatchSize ); delete G; return rc; } void SDASelHandles::getNewHandles ( PCMMDBManager MMDB ) { selHndDonor = MMDB->NewSelection(); selHndAcceptor = MMDB->NewSelection(); selHndHydrogen = MMDB->NewSelection(); selKey = SKEY_OR; } void SDASelHandles::makeSelIndexes ( PCMMDBManager MMDB ) { MMDB->MakeSelIndex ( selHndDonor ); MMDB->MakeSelIndex ( selHndAcceptor ); MMDB->MakeSelIndex ( selHndHydrogen ); } void SDASelHandles::deleteSelections ( PCMMDBManager MMDB ) { MMDB->DeleteSelection ( selHndDonor ); MMDB->DeleteSelection ( selHndAcceptor ); MMDB->DeleteSelection ( selHndHydrogen ); } int CSBase0::MakeBonds ( PCResidue R, pstr altLoc, PCFile structFile, PSDASelHandles selHandles, Boolean ignoreNegSigOcc ) { // MakeBonds(..) makes bonds between atoms in MMDB's residue R // from data found in SBase. Residue R must be associated with // coordinate hierarchy. Data is retrieved from SBase on the basis // of residue name only. In case of multiple conformations, if // altLoc: // NULL - the highest occupancy atom will be taken // if all occupancies are equal then atom with // first altLoc taken // other - atoms with given altLoc are taken. If such // altLoc is not found, the function does as if // NULL value for altLoc is given. // If selHandles is not NULL, the function also selects atoms // in the residue according to their hydrogen bond attributes. // This is a special option for hydrogen bond calculations. // If ignoreNegSigOcc is set True then the function will ignore // atoms with negative occupancy standard deviation. Such atoms // may be hydrogens added by CSBase0::AddHydrogens(..) function, // in general any atoms added by CSBAtom::MakeCAtom(..) function. // Added hydrogens may be ignored if MakeBonds is used in // CSbase::CalcHBonds(..) function. // Return: // SBASE_Ok success // SBASE_FileNotFound non-initiated SBase // SBASE_StructNotFound the residue's name is not found in SBase // SBASE_EmptyResidue residue R does not contain atoms // SBASE_NoAtomsFound SBase entry does not contain atoms // SBASE_BrokenBonds some bonds could not be set up because // of missing atoms in R. This could be // a result of residue R named wrongly. PCSBStructure SBS; PCMMDBManager MMDB; PPCAtom A; ivector anmatch; int natoms,i,i1,i2,rc; R->GetAtomTable ( A,natoms ); if (!A) return SBASE_EmptyResidue; for (i=0;iFreeBonds(); SBS = GetStructure ( R->GetResName(),structFile ); if (!SBS) return SBASE_StructNotFound; if (SBS->nAtoms<=0) { delete SBS; return SBASE_NoAtomsFound; } GetVectorMemory ( anmatch,SBS->nAtoms,0 ); SBS->GetAtomNameMatch ( A,natoms,altLoc,anmatch ); if (ignoreNegSigOcc) for (i=0;inAtoms;i++) { i1 = anmatch[i]; if (i1>=0) { if (A[i1]->sigOcc<0.0) anmatch[i] = -1; } } if (selHandles) { MMDB = PCMMDBManager(R->GetCoordHierarchy()); if (MMDB) { i2 = selHandles->selKey; for (i=0;inAtoms;i++) { i1 = anmatch[i]; if (i1>=0) switch (SBS->Atom[i]->hb_type) { case 'D' : MMDB->SelectAtom ( selHandles->selHndDonor, A[i1],i2,False ); break; case 'A' : MMDB->SelectAtom ( selHandles->selHndAcceptor, A[i1],i2,False ); break; case 'B' : MMDB->SelectAtom ( selHandles->selHndDonor, A[i1],i2,False ); MMDB->SelectAtom ( selHandles->selHndAcceptor, A[i1],i2,False ); break; case 'H' : MMDB->SelectAtom ( selHandles->selHndHydrogen, A[i1],i2,False ); break; default : case 'N' : ; } } } } rc = SBASE_Ok; for (i=0;inBonds;i++) { i1 = anmatch[SBS->Bond[i]->atom1-1]; i2 = anmatch[SBS->Bond[i]->atom2-1]; if ((i1>=0) && (i2>=0)) { A[i1]->AddBond ( A[i2],SBS->Bond[i]->order,2 ); A[i2]->AddBond ( A[i1],SBS->Bond[i]->order,2 ); } else rc = SBASE_BrokenBonds; } FreeVectorMemory ( anmatch,0 ); delete SBS; return rc; } int CSBase0::GetEnergyTypes ( PCResidue R, PCFile structFile ) { PCSBStructure SBS; PPCAtom A; int i,j,rc,natoms; R->GetAtomTable ( A,natoms ); if (!A) return SBASE_EmptyResidue; for (i=0;ienergyType[0] = char(0); SBS = GetStructure ( R->GetResName(),structFile ); if (SBS) { if (SBS->nAtoms>0) { for (i=0;inAtoms;j++) if (SBS->Atom[j]) { if (!strcmp(A[i]->name,SBS->Atom[j]->pdb_name)) { strcpy ( A[i]->energyType,SBS->Atom[j]->energyType ); A[i]->charge = SBS->Atom[j]->ccp4_charge; } } } rc = SBASE_Ok; } else rc = SBASE_NoAtomsFound; delete SBS; } else rc = SBASE_StructNotFound; return rc; } int CSBase0::GetEnergyTypes ( PPCResidue R, int nRes, PCFile structFile ) { PCFile sFile; PCSBStructure SBS; PPCAtom A; bvector B; int i,j,k,n,natoms; GetVectorMemory ( B,nRes,0 ); for (i=0;iGetResName(),sFile ); j = i; while (jGetAtomTable ( A,natoms ); if (A) { for (k=0;kenergyType[0] = char(0); if (SBS) { if (SBS->nAtoms>0) { for (k=0;knAtoms;n++) if (SBS->Atom[n]) { if (!strcmp(A[k]->name,SBS->Atom[n]->pdb_name)) { strcpy ( A[k]->energyType, SBS->Atom[n]->energyType ); A[k]->charge = SBS->Atom[n]->ccp4_charge; } } } } } } j++; while (jname,R[j]->name)) break; else j++; } else j++; } if (SBS) { delete SBS; SBS = NULL; } i++; } } if (!structFile) delete sFile; FreeVectorMemory ( B,0 ); return SBASE_Ok; } int CSBase0::GetEnergyTypes ( PCChain chain, PCFile structFile ) { PPCResidue Res; int nRes; chain->GetResidueTable ( Res,nRes ); if (nRes>0) return GetEnergyTypes ( Res,nRes,structFile ); else return SBASE_EmptyResSet; } int CSBase0::GetEnergyTypes ( PCModel model, PCFile structFile ) { PPCResidue Res; PPCChain chain; PCMMDBManager MMDB; int rc,selHnd,i,nRes,nChains; rc = SBASE_Ok; MMDB = PCMMDBManager(model->GetCoordHierarchy()); if (MMDB) { selHnd = MMDB->NewSelection(); MMDB->Select ( selHnd,STYPE_RESIDUE,model->GetSerNum(), "*",ANY_RES,"*",ANY_RES,"*", "*","*","*","*",SKEY_NEW ); MMDB->GetSelIndex ( selHnd,Res,nRes ); if (nRes>0) rc = GetEnergyTypes ( Res,nRes,structFile ); else rc = SBASE_EmptyResSet; MMDB->DeleteSelection ( selHnd ); } else { model->GetChainTable ( chain,nChains ); for (i=0;iGetResidueTable ( Res,nRes ); if (nRes>0) GetEnergyTypes ( Res,nRes,structFile ); } } return rc; } int CSBase0::GetEnergyTypes ( PCMMDBManager MMDB, PCFile structFile ) { PPCResidue Res; int rc,selHnd,nRes; rc = SBASE_Ok; selHnd = MMDB->NewSelection(); MMDB->Select ( selHnd,STYPE_RESIDUE,0, "*",ANY_RES,"*",ANY_RES,"*", "*","*","*","*",SKEY_NEW ); MMDB->GetSelIndex ( selHnd,Res,nRes ); if (nRes>0) rc = GetEnergyTypes ( Res,nRes,structFile ); else rc = SBASE_EmptyResSet; MMDB->DeleteSelection ( selHnd ); return rc; } int CSBase0::AddHydrogens ( PCResidue R, PCFile structFile ) { // Return: // SBASE_Ok success // SBASE_EmptyResidue residue R does not contain atoms // SBASE_NoAtomsFound SBStructure does not contain atoms // SBASE_NoBonds SBStructure does not contain bonds // SBASE_NoAtomsData SBStructure is not complete // SBASE_NoSimilarity too few coomon atom names in R and SBase // entry with the same structure name // SBASE_SuperpositionFailed failed residue superposition // NOTE: the function does not rearranges existing atoms in the // residue, but places the hydrogens on top of them (leaving the // Ter pseudoatom, if found, on top of the list) PCFile sFile; PCSBStructure SBS; int rc; if (structFile) sFile = structFile; else sFile = GetStructFile(); if (!sFile) return SBASE_FileNotFound; SBS = GetStructure ( R->GetResName(),sFile ); if (!structFile) delete sFile; if (!SBS) return SBASE_StructNotFound; rc = SBS->AddHydrogens ( R ); delete SBS; return rc; } int CSBase0::AddHydrogens ( PCChain chain, PCFile structFile ) { PCFile sFile; PPCResidue Res; int i,k,nRes,rc; Boolean B; if (structFile) sFile = structFile; else sFile = GetStructFile(); if (!sFile) return SBASE_FileNotFound; rc = SBASE_Ok; B = False; chain->GetResidueTable ( Res,nRes ); for (i=0;iGetChainTable ( chain,nChains ); for (i=0;iGetResidueTable ( Res,nRes ); for (j=0;jGetModelTable ( model,nModels ); for (i=0;iGetChainTable ( chain,nChains ); for (j=0;jGetResidueTable ( Res,nRes ); for (n=0;nGetResName(),sFile ); if (!structFile) delete sFile; if (!SBS) return SBASE_StructNotFound; /* --- temporary commented because of incompleteness of data in SBase files if (SBS->CheckAtoms()<0) { delete SBS; return SBASE_NoAtomData; } ---------- */ rc = SBASE_Ok; SBS->GetAtomTable ( A1,natoms1 ); if (!A1) { delete SBS; return SBASE_NoAtomsFound; } /* --- temporary fix, simply neglect atoms that do not have coordinates. This code should be removed and the code above uncommented ----------- */ j = 0; for (i=0;ix==-MaxReal) delete A1[i]; else { if (jGetAtomTable ( A2,natoms2 ); if (!A2) { delete SBS; return SBASE_EmptyResidue; } GetVectorMemory ( c,natoms1,0 ); GetVectorMemory ( x,natoms2,0 ); for (j=0;jisTer()) && (!strcmp(A1[i]->GetAtomName(),A2[j]->GetAtomName()))) { if (c[i]<0) { c[i] = j; k++; } x[j] = i; } } } if (k>2) { // the rotational-translational matrix T such that |T*A1 - A2| is // as A1[i] <-> A2[C[i]] only for those i that C[i]>=0 . // The default k = SuperposeAtoms ( T,A1,natoms1,A2,c ); if (k!=SPOSEAT_Ok) rc = SBASE_SuperpositionFailed; else { complH = ((complFlag & CMPLF_Hydrogens)!=0); complNH = ((complFlag & CMPLF_nonHs)!=0); complXT = ((complFlag & CMPLF_XT)!=0); strcpy ( Hydrogen,ElementName[0] ); CutSpaces ( Hydrogen,SCUTKEY_BEGEND ); A3 = new PCAtom[natoms1+natoms2+1]; k = 0; for (i=0;i=0) { A3[k] = A1[i]; A3[k]->Copy ( A2[c[i]] ); A1[i] = NULL; k++; // check for altlocs for (j=c[i]+1;jCopy ( A2[j] ); k++; } } else { A3[k] = NULL; aname = A1[i]->GetAtomName(); if (strcmp(A1[i]->GetElementName(),Hydrogen)) { // a non-hydrogen atom, check if it should be added if (complNH && (complXT || (strcmp(aname," OXT")))) A3[k] = A1[i]; } else if (complH) { // a hydrogen and hydrogens are to be added if (complXT) A3[k] = A1[i]; // add unconditionally else if (!strcmp(aname," HXT")) { // add HXT only if OXT is present in the residue for (j=0;(jisTer()) && (!strcmp(A2[j]->GetAtomName()," OXT"))) A3[k] = A1[i]; } } else // add non-HXT anyway A3[k] = A1[i]; } if (A3[k]) { A3[k]->Transform ( T ); A1[i] = NULL; k++; } } // add all atoms of original residue which were not superposed; // these include Ter, if any is present for (j=0;jCopy ( A2[j] ); k++; } R->DeleteAllAtoms(); for (i=0;iAddAtom ( A3[i] ); delete[] A3; } } else rc = SBASE_NoSimilarity; FreeVectorMemory ( x,0 ); FreeVectorMemory ( c,0 ); for (i=0;iGetResidueTable ( Res,nRes ); for (i=0;iGetChainTable ( chain,nChains ); for (i=0;iGetResidueTable ( Res,nRes ); for (j=0;jGetModelTable ( model,nModels ); for (i=0;iGetChainTable ( chain,nChains ); for (j=0;jGetResidueTable ( Res,nRes ); for (n=0;n=nStructures)) return SBASE_WrongIndex; if (Index[structNo]->loadPos>=0) { rc = GetAtNames ( NULL,structNo,AtName,nAtoms,nH ); } else { structFile = GetStructFile(); if (structFile) { rc = GetAtNames ( structFile,structNo,AtName,nAtoms,nH ); structFile->shut(); delete structFile; } else return SBASE_FileNotFound; } return rc; } int CSBase0::GetAtNames ( PCFile structFile, int structNo, PAtomName AtName, int & nAtoms, int & nH ) { PCSBStructure SBS; PCSBAtom atom; int i,j; pstr p1,p2; Boolean removeHydrogens; if ((structNo<0) || (structNo>=nStructures)) return SBASE_WrongIndex; removeHydrogens = (nH==-1); if (Index[structNo]->loadPos>=0) { SBS = ldStructure[Index[structNo]->loadPos]; } else { structFile->seek ( Index[structNo]->fStructPos ); SBS = NULL; StreamRead ( *structFile,SBS ); if ((!SBS) || (!structFile->Success())) { if (SBS) delete SBS; return SBASE_ReadError; } } nAtoms = Index[structNo]->nAtoms; nH = 0; if (Index[structNo]->Comp1) { p1 = strstr ( Index[structNo]->Comp1,"H(" ); if (p1) { p1 += 2; p2 = p1; while ((*p2) && (*p2!=')')) p2++; if (*p2==')') { *p2 = char(0); nH = mround(strtod(p1,NULL)); *p2 = ')'; } } } if (removeHydrogens) { j = 0; for (i=0;iAtom[i]; if (atom) { if ((atom->element[0]!='H') || (atom->element[1])) strcpy ( AtName[j++],atom->pdb_name ); } } } else { for (i=0;iAtom[i]; if (atom) strcpy ( AtName[i],atom->pdb_name ); } } if (Index[structNo]->loadPos<0) delete SBS; return SBASE_Ok; } int FindName ( PAtomName Nams, pstr N, int len ) { int i; AtomName Nam; i = 0; while (i=len) i = -1; return i; } int CSBase0::GetNofAtoms ( int structNo, int & nNonHAtoms, int & nHAtoms ) { pstr p1,p2; nNonHAtoms = 0; nHAtoms = 0; if ((structNo<0) || (structNo>=nStructures)) return SBASE_WrongIndex; nNonHAtoms = Index[structNo]->nAtoms; nHAtoms = 0; if (Index[structNo]->Comp1) { p1 = strstr ( Index[structNo]->Comp1,"H(" ); if (p1) { p1 += 2; p2 = p1; while ((*p2) && (*p2!=')')) p2++; if (*p2==')') { *p2 = char(0); nHAtoms = mround(strtod(p1,NULL)); *p2 = ')'; } } } nNonHAtoms -= nHAtoms; return SBASE_Ok; } int CSBase0::GetAtoms ( cpstr name, int & nNonHAtoms, PAtomName NonHAtName, int & nHAtoms, PAtomName HAtName, ivector Hconnect, ivector Elem, ivector Chiral ) { PCSBStructure SBS; PCSBAtom atom,atom2; PCSBBond bond; int i,j,structNo,rc; PCFile structFile; nNonHAtoms = 0; nHAtoms = 0; structNo = GetStructNo ( name ); if (structNo<0) return SBASE_StructNotFound; if (Index[structNo]->loadPos>=0) { SBS = ldStructure[Index[structNo]->loadPos]; } else { structFile = GetStructFile(); if (!structFile) return SBASE_FileNotFound; SBS = NULL; structFile->seek ( Index[structNo]->fStructPos ); StreamRead ( *structFile,SBS ); structFile->shut (); if ((!SBS) || (!structFile->Success())) { if (SBS) delete SBS; delete structFile; return SBASE_ReadError; } delete structFile; } rc = SBASE_Ok; for (i=0;inAtoms;i++) { atom = SBS->Atom[i]; if (atom) { Elem[i] = getElementNo ( atom->element ); if ((atom->element[0]==' ') && (atom->element[1]=='H') && (!atom->element[2])) { strcpy ( HAtName[nHAtoms],atom->pdb_name ); nHAtoms++; } else { strcpy ( NonHAtName[nNonHAtoms],atom->pdb_name ); nNonHAtoms++; } Chiral[i] = MakeChirInd ( atom->chirality ); } } if (nHAtoms>0) { for (j=0;jnBonds;i++) { bond = SBS->Bond[i]; if (bond) { atom = SBS->Atom[bond->atom1-1]; atom2 = SBS->Atom[bond->atom2-1]; if (atom && atom2) { j = FindName ( HAtName,atom->pdb_name,nHAtoms ); if (j>=0) Hconnect[j] = FindName ( NonHAtName,atom2->pdb_name, nNonHAtoms ); else { j = FindName ( HAtName,atom2->pdb_name,nHAtoms ); if (j>=0) Hconnect[j] = FindName ( NonHAtName,atom->pdb_name, nNonHAtoms ); } } } } j = 0; while ((j=0)) j++; if (jloadPos<0) delete SBS; return rc; } int CSBase0::GetBonds ( cpstr name, ivector nBonds, imatrix bondPair, int & nAtoms, int maxNAtoms, int maxNBonds ) { PCGraph G; PCEdge edge; PCFile graphFile; int structNo,i, a1,a2; for (i=0;inAtoms; if (nAtoms<=0) return SBASE_Ok; if (Index[structNo]->loadPos>=0) { G = ldGraph[Index[structNo]->loadPos]; } else { graphFile = GetGraphFile(); if (!graphFile) return SBASE_FileNotFound; G = NULL; graphFile->seek ( Index[structNo]->fGraphPos ); StreamRead ( *graphFile,G ); graphFile->shut (); if ((!G) || (!graphFile->Success())) { if (G) delete G; delete graphFile; return SBASE_ReadError; } delete graphFile; } for (i=0;inEdges;i++) { edge = G->Edge[i]; if (edge) { if (edge->v1v2) { a1 = edge->v1; a2 = edge->v2; } else { a1 = edge->v2; a2 = edge->v1; } a1--; a2--; if (nBonds[a1]loadPos<0) delete G; return SBASE_Ok; } int CSBase0::GetHetInfo ( cpstr name, pstr Formula, pstr Hname, pstr Hsynonym, pstr Hcharge, PAtomName & ClinkAtom, PElement & ClinkEle, PAtomName & SlinkAtom, PElement & SlinkEle, int & nLeavingAtoms ) { PCSBStructure SBS; PCFile structFile; int i,structNo; Formula [0] = char(0); Hname [0] = char(0); Hsynonym[0] = char(0); Hcharge [0] = char(0); ClinkAtom = NULL; ClinkEle = NULL; SlinkAtom = NULL; SlinkEle = NULL; nLeavingAtoms = 0; structNo = GetStructNo ( name ); if (structNo<0) return SBASE_StructNotFound; structFile = GetStructFile(); if (!structFile) return SBASE_FileNotFound; SBS = NULL; structFile->seek ( Index[structNo]->fStructPos ); StreamRead ( *structFile,SBS ); structFile->shut (); if ((!SBS) || (!structFile->Success())) { if (SBS) delete SBS; delete structFile; return SBASE_ReadError; } delete structFile; if (SBS->Formula) strcpy ( Formula ,SBS->Formula ); if (SBS->Synonym) strcpy ( Hsynonym,SBS->Synonym ); if (SBS->Name) strcpy ( Hname ,SBS->Name ); if (SBS->Charge) strcpy ( Hcharge ,SBS->Charge ); nLeavingAtoms = SBS->nLeavingAtoms; if (nLeavingAtoms>0) { SlinkAtom = new AtomName[nLeavingAtoms]; SlinkEle = new Element [nLeavingAtoms]; ClinkAtom = new AtomName[nLeavingAtoms]; ClinkEle = new Element [nLeavingAtoms]; for (i=0;iAtom[SBS->leavingAtom[i]-1]->pdb_name); strcpy (SlinkEle [i],SBS->Atom[SBS->leavingAtom[i]-1]->element ); if (SBS->bondedAtom[i]>0) { strcpy(ClinkAtom[i],SBS->Atom[SBS->bondedAtom[i]-1]->pdb_name); strcpy(ClinkEle [i],SBS->Atom[SBS->bondedAtom[i]-1]->element ); } else { ClinkAtom[i][0] = char(0); ClinkEle [i][0] = char(0); } } } delete SBS; return SBASE_Ok; } mmdb-1.25.5/mmdb/mmdb_ficif.cpp0000775000175000017500000004521711736610510013164 00000000000000// $Id: mmdb_ficif.cpp,v 1.19 2012/01/26 17:52:20 ekr Exp $ // ================================================================= // // CCP4 Coordinate Library: support of coordinate-related // functionality in protein crystallography applications. // // Copyright (C) Eugene Krissinel 2000-2008. // // This library is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // // ================================================================= // // 24.04.03 <-- Date of Last Modification. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ----------------------------------------------------------------- // // **** Module : MMDB_FICIF // ~~~~~~~~~ // **** Project : MacroMolecular Data Base (MMDB) // ~~~~~~~~~ // **** Classes : // ~~~~~~~~~ // // (C) E. Krissinel 2000-2008 // // ================================================================= // #ifndef __MMDB_MMCIF__ #include "mmdb_mmcif.h" #endif #ifndef __MMDB_FICIF__ #include "mmdb_ficif.h" #endif // ================================================================== PCMMCIFData mmCIFData = NULL; FORTRAN_SUBR ( MMDB_FCIF_INIT, mmdb_fcif_init,(),(),() ) { InitMatType(); mmCIFData = NULL; } void MMDB_CCIF_Init() { InitMatType(); mmCIFData = NULL; } FORTRAN_SUBR ( MMDB_FCIF_QUIT, mmdb_fcif_quit,(),(),() ) { if (mmCIFData) delete mmCIFData; mmCIFData = NULL; } void MMDB_CCIF_Quit() { if (mmCIFData) delete mmCIFData; mmCIFData = NULL; } pstr makeString ( pstr S, int SLen, pstr FS, int FSLen ) { GetStrTer ( S,FS,FSLen,SLen,FSLen ); CutSpaces ( S,SCUTKEY_END ); return S; } FORTRAN_SUBR ( MMDB_FCIF_CREATE, mmdb_fcif_create, ( // lengths-at-end list fpstr DataName, // file name int DataName_len // fortran-hidden length of DataName ), ( // lengths-in-structure list fpstr DataName ), ( // lengths-follow list fpstr DataName, int DataName_len ) ) { char S[500]; if (mmCIFData) delete mmCIFData; mmCIFData = new CMMCIFData ( makeString(S,sizeof(S), FTN_STR(DataName),FTN_LEN(DataName)) ); } void MMDB_CCIF_Create ( pstr DataName ) { if (mmCIFData) delete mmCIFData; mmCIFData = new CMMCIFData ( DataName ); } FORTRAN_SUBR ( MMDB_FCIF_WRITE, mmdb_fcif_write, ( // lengths-at-end list fpstr FileName, // file name int * iRet, // return code int FileName_len // fortran-hidden length of FileName ), ( // lengths-in-structure list fpstr FileName, int *iRet ), ( // lengths-follow list fpstr FileName, int FileName_len, int * iRet ) ) { pstr S; if (!mmCIFData) *iRet = -1000; else { S = new char[FTN_LEN(FileName)+10]; if (mmCIFData->WriteMMCIFData(makeString(S,FTN_LEN(FileName)+5, FTN_STR(FileName),FTN_LEN(FileName)))) *iRet = 0; else *iRet = 1; delete[] S; } } int MMDB_CCIF_Write ( pstr FileName ) { if (!mmCIFData) return -1000; else if (mmCIFData->WriteMMCIFData(FileName)) return 0; else return 1; } FORTRAN_SUBR ( MMDB_FCIF_PUTDATE, mmdb_fcif_putdate, ( // lengths-at-end list fpstr CatName, // category name fpstr Tag, // tag int * iRet, // return code int CatName_len, // fortran-hidden length of CatName int Tag_len // fortran-hidden length of Tag ), ( // lengths-in-structure list fpstr CatName, fpstr Tag, int * iRet ), ( // lengths-follow list fpstr CatName, int CatName_len, fpstr Tag, int Tag_len, int * iRet ) ) { char CN[200],TN[200]; if (!mmCIFData) *iRet = -1000; else *iRet = mmCIFData->PutDate ( makeString(CN,sizeof(CN), FTN_STR(CatName),FTN_LEN(CatName)), makeString(TN,sizeof(TN), FTN_STR(Tag),FTN_LEN(Tag)) ); } int MMDB_CCIF_PutDate ( pstr CatName, pstr Tag ) { if (!mmCIFData) return -1000; else return mmCIFData->PutDate ( CatName,Tag ); } FORTRAN_SUBR ( MMDB_FCIF_PUTDOT, mmdb_fcif_putdot, ( // lengths-at-end list fpstr CatName, // category name fpstr Tag, // tag int * iRet, // return code int CatName_len, // fortran-hidden length of CatName int Tag_len // fortran-hidden length of Tag ), ( // lengths-in-structure list fpstr CatName, fpstr Tag, int * iRet ), ( // lengths-follow list fpstr CatName, int CatName_len, fpstr Tag, int Tag_len, int * iRet ) ) { char CN[200],TN[200]; if (!mmCIFData) *iRet = -1000; else *iRet = mmCIFData->PutNoData ( CIF_NODATA_DOT, makeString(CN,sizeof(CN), FTN_STR(CatName),FTN_LEN(CatName)), makeString(TN,sizeof(TN), FTN_STR(Tag),FTN_LEN(Tag)) ); } int MMDB_CCIF_PutDot ( pstr CatName, pstr Tag ) { if (!mmCIFData) return -1000; else return mmCIFData->PutNoData ( CIF_NODATA_DOT, CatName,Tag ); } FORTRAN_SUBR ( MMDB_FCIF_PUTQUESTION, mmdb_fcif_putquestion, ( // lengths-at-end list fpstr CatName, // category name fpstr Tag, // tag int * iRet, // return code int CatName_len, // fortran-hidden length of CatName int Tag_len // fortran-hidden length of Tag ), ( // lengths-in-structure list fpstr CatName, fpstr Tag, int * iRet ), ( // lengths-follow list fpstr CatName, int CatName_len, fpstr Tag, int Tag_len, int * iRet ) ) { char CN[200],TN[200]; if (!mmCIFData) *iRet = -1000; else *iRet = mmCIFData->PutNoData ( CIF_NODATA_QUESTION, makeString(CN,sizeof(CN), FTN_STR(CatName),FTN_LEN(CatName)), makeString(TN,sizeof(TN), FTN_STR(Tag),FTN_LEN(Tag)) ); } int MMDB_CCIF_PutQuestion ( pstr CatName, pstr Tag ) { if (!mmCIFData) return -1000; else return mmCIFData->PutNoData ( CIF_NODATA_QUESTION, CatName,Tag ); } FORTRAN_SUBR ( MMDB_FCIF_PUTSTRING, mmdb_fcif_putstring, ( // lengths-at-end list fpstr Data, // data string to store fpstr CatName, // category name fpstr Tag, // tag int * iRet, // return code int Data_len, // fortran-hidden length of Data int CatName_len, // fortran-hidden length of CatName int Tag_len // fortran-hidden length of Tag ), ( // lengths-in-structure list fpstr Data, fpstr CatName, fpstr Tag, int * iRet ), ( // lengths-follow list fpstr Data, int Data_len, fpstr CatName, int CatName_len, fpstr Tag, int Tag_len, int * iRet ) ) { char CN[200],TN[200]; pstr S; if (!mmCIFData) *iRet = -1000; else { S = new char[FTN_LEN(Data)+10]; *iRet = mmCIFData->PutString ( makeString(S,FTN_LEN(Data)+5, FTN_STR(Data),FTN_LEN(Data)), makeString(CN,sizeof(CN), FTN_STR(CatName),FTN_LEN(CatName)), makeString(TN,sizeof(TN), FTN_STR(Tag),FTN_LEN(Tag)) ); delete[] S; } } int MMDB_CCIF_PutString ( pstr Data, pstr CatName, pstr Tag ) { if (!mmCIFData) return -1000; else return mmCIFData->PutString ( Data,CatName,Tag ); } FORTRAN_SUBR ( MMDB_FCIF_PUTREAL, mmdb_fcif_putreal, ( // lengths-at-end list apireal * V, // real value to store fpstr CatName, // category name fpstr Tag, // tag int * iRet, // return code int CatName_len, // fortran-hidden length of CatName int Tag_len // fortran-hidden length of Tag ), ( // lengths-in-structure list apireal * V, fpstr CatName, fpstr Tag, int * iRet ), ( // lengths-follow list apireal * V, fpstr CatName, int CatName_len, fpstr Tag, int Tag_len, int * iRet ) ) { char CN[200],TN[200]; if (!mmCIFData) *iRet = -1000; else *iRet = mmCIFData->PutReal ( *V, makeString(CN,sizeof(CN), FTN_STR(CatName),FTN_LEN(CatName)), makeString(TN,sizeof(TN), FTN_STR(Tag),FTN_LEN(Tag)) ); } int MMDB_CCIF_PutReal ( realtype V, pstr CatName, pstr Tag ) { if (!mmCIFData) return -1000; else return mmCIFData->PutReal ( V,CatName,Tag ); } FORTRAN_SUBR ( MMDB_FCIF_PUTINTEGER, mmdb_fcif_putinteger, ( // lengths-at-end list int * I, // integer value to store fpstr CatName, // category name fpstr Tag, // tag int * iRet, // return code int CatName_len, // fortran-hidden length of CatName int Tag_len // fortran-hidden length of Tag ), ( // lengths-in-structure list int * I, fpstr CatName, fpstr Tag, int * iRet ), ( // lengths-follow list int * I, fpstr CatName, int CatName_len, fpstr Tag, int Tag_len, int * iRet ) ) { char CN[200],TN[200]; if (!mmCIFData) *iRet = -1000; else *iRet = mmCIFData->PutInteger ( *I, makeString(CN,sizeof(CN), FTN_STR(CatName),FTN_LEN(CatName)), makeString(TN,sizeof(TN), FTN_STR(Tag),FTN_LEN(Tag)) ); } int MMDB_CCIF_PutInteger ( int I, pstr CatName, pstr Tag ) { if (!mmCIFData) return -1000; else return mmCIFData->PutInteger ( I,CatName,Tag ); } FORTRAN_SUBR ( MMDB_FCIF_PUTLOOPDOT, mmdb_fcif_putloopdot, ( // lengths-at-end list fpstr CatName, // category name fpstr Tag, // tag int * nrow, // row number int * iRet, // return code int CatName_len, // fortran-hidden length of CatName int Tag_len // fortran-hidden length of Tag ), ( // lengths-in-structure list fpstr CatName, fpstr Tag, int * nrow, int * iRet ), ( // lengths-follow list fpstr CatName, int CatName_len, fpstr Tag, int Tag_len, int * nrow, int * iRet ) ) { char CN[200],TN[200]; if (!mmCIFData) *iRet = -1000; else *iRet = mmCIFData->PutLoopNoData ( CIF_NODATA_DOT, makeString(CN,sizeof(CN), FTN_STR(CatName),FTN_LEN(CatName)), makeString(TN,sizeof(TN), FTN_STR(Tag),FTN_LEN(Tag)),*nrow ); } int MMDB_CCIF_PutLoopDot ( pstr CatName, pstr Tag, int nrow ) { if (!mmCIFData) return -1000; else return mmCIFData->PutLoopNoData ( CIF_NODATA_DOT, CatName,Tag,nrow ); } FORTRAN_SUBR ( MMDB_FCIF_PUTLOOPQUESTION, mmdb_fcif_putloopquestion, ( // lengths-at-end list fpstr CatName, // category name fpstr Tag, // tag int * nrow, // row number int * iRet, // return code int CatName_len, // fortran-hidden length of CatName int Tag_len // fortran-hidden length of Tag ), ( // lengths-in-structure list fpstr CatName, fpstr Tag, int * nrow, int * iRet ), ( // lengths-follow list fpstr CatName, int CatName_len, fpstr Tag, int Tag_len, int * nrow, int * iRet ) ) { char CN[200],TN[200]; if (!mmCIFData) *iRet = -1000; else *iRet = mmCIFData->PutLoopNoData ( CIF_NODATA_QUESTION, makeString(CN,sizeof(CN), FTN_STR(CatName),FTN_LEN(CatName)), makeString(TN,sizeof(TN), FTN_STR(Tag),FTN_LEN(Tag)),*nrow ); } int MMDB_CCIF_PutLoopQuestion ( pstr CatName, pstr Tag, int nrow ) { if (!mmCIFData) return -1000; else return mmCIFData->PutLoopNoData ( CIF_NODATA_QUESTION, CatName,Tag,nrow ); } FORTRAN_SUBR ( MMDB_FCIF_PUTLOOPSTRING, mmdb_fcif_putloopstring, ( // lengths-at-end list fpstr Data, // data string to store fpstr CatName, // category name fpstr Tag, // tag int * nrow, // row number int * iRet, // return code int Data_len, // fortran-hidden length of Data int CatName_len, // fortran-hidden length of CatName int Tag_len // fortran-hidden length of Tag ), ( // lengths-in-structure list fpstr Data, fpstr CatName, fpstr Tag, int * nrow, int * iRet ), ( // lengths-follow list fpstr Data, int Data_len, fpstr CatName, int CatName_len, fpstr Tag, int Tag_len, int * nrow, int * iRet ) ) { char CN[200],TN[200]; pstr S; if (!mmCIFData) *iRet = -1000; else { S = new char[FTN_LEN(Data)+10]; *iRet = mmCIFData->PutLoopString ( makeString(S,FTN_LEN(Data)+5, FTN_STR(Data),FTN_LEN(Data)), makeString(CN,sizeof(CN), FTN_STR(CatName),FTN_LEN(CatName)), makeString(TN,sizeof(TN), FTN_STR(Tag),FTN_LEN(Tag)),*nrow ); delete[] S; } } int MMDB_CCIF_PutLoopString ( pstr Data, pstr CatName, pstr Tag, int nrow ) { if (!mmCIFData) return -1000; else return mmCIFData->PutLoopString ( Data,CatName,Tag,nrow ); } FORTRAN_SUBR ( MMDB_FCIF_PUTLOOPREAL, mmdb_fcif_putloopreal, ( // lengths-at-end list apireal * V, // real value to store fpstr CatName, // category name fpstr Tag, // tag int * nrow, // row number int * iRet, // return code int CatName_len, // fortran-hidden length of CatName int Tag_len // fortran-hidden length of Tag ), ( // lengths-in-structure list apireal * V, fpstr CatName, fpstr Tag, int * nrow, int * iRet ), ( // lengths-follow list apireal * V, fpstr CatName, int CatName_len, fpstr Tag, int Tag_len, int * nrow, int * iRet ) ) { char CN[200],TN[200]; if (!mmCIFData) *iRet = -1000; else *iRet = mmCIFData->PutLoopReal ( *V, makeString(CN,sizeof(CN), FTN_STR(CatName),FTN_LEN(CatName)), makeString(TN,sizeof(TN), FTN_STR(Tag),FTN_LEN(Tag)),*nrow ); } int MMDB_CCIF_PutLoopReal ( realtype V, pstr CatName, pstr Tag, int nrow ) { if (!mmCIFData) return -1000; else return mmCIFData->PutLoopReal ( V,CatName,Tag,nrow ); } FORTRAN_SUBR ( MMDB_FCIF_PUTLOOPINTEGER, mmdb_fcif_putloopinteger, ( // lengths-at-end list int * I, // integer value to store fpstr CatName, // category name fpstr Tag, // tag int * nrow, // row number int * iRet, // return code int CatName_len, // fortran-hidden length of CatName int Tag_len // fortran-hidden length of Tag ), ( // lengths-in-structure list int * I, fpstr CatName, fpstr Tag, int * nrow, int * iRet ), ( // lengths-follow list int * I, fpstr CatName, int CatName_len, fpstr Tag, int Tag_len, int * nrow, int * iRet ) ) { char CN[200],TN[200]; if (!mmCIFData) *iRet = -1000; else *iRet = mmCIFData->PutLoopInteger ( *I, makeString(CN,sizeof(CN), FTN_STR(CatName),FTN_LEN(CatName)), makeString(TN,sizeof(TN), FTN_STR(Tag),FTN_LEN(Tag)),*nrow ); } int MMDB_CCIF_PutLoopInteger ( int I, pstr CatName, pstr Tag, int nrow ) { if (!mmCIFData) return -1000; else return mmCIFData->PutLoopInteger ( I,CatName,Tag,nrow ); } mmdb-1.25.5/mmdb/mattype_.cpp0000775000175000017500000013761711770570036012743 00000000000000// $Id: mattype_.cpp,v 1.30 2012/01/26 17:52:19 ekr Exp $ // ================================================================= // // CCP4 Coordinate Library: support of coordinate-related // functionality in protein crystallography applications. // // Copyright (C) Eugene Krissinel 2000-2008. // // This library is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // // ================================================================= // // 29.01.10 <-- Date of Last Modification. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ----------------------------------------------------------------- // // **** Module : MatType_ // ~~~~~~~~~ // // (C) E. Krissinel 2000-2010 // // ================================================================= // #ifndef __STDLIB_H #include #endif #ifndef __STRING_H #include #endif #ifndef __CTYPE_H #include #endif #ifndef __MatType__ #include "mattype_.h" #endif #include #include // ------------------------------------------------------- realtype MachEps; realtype floatMachEps; realtype LnMaxReal; realtype LnMinReal; static realtype LnMaxRealExp; static realtype LnMinRealExp; // Initialization. Some C++ enviroments do not do the // following statements automatically, therefore it is // always advisable to call InitMatType() explicitely // from the top of main(). See body of InitMatType() // in the very end of this file. It is completely // harmless and cheap to call InitMatType() multiple // times. static Boolean MatTypeInit = InitMatType(); // ------------------------------------------------------- /* int mround ( realtype X ) { return (int)floor(X+0.5); } int ifloor ( realtype X ) { return (int)floor(X); } int Abs ( int x ) { return ( x >= 0 ? x : -x ); } */ #ifdef _WIN32 pstr strcasestr ( pstr s1, cpstr s2 ) { pstr l1,l2,l; l1 = NULL; l2 = NULL; CreateCopy ( l1,s1 ); CreateCopy ( l2,s2 ); LowerCase ( l1 ); LowerCase ( l2 ); l = strstr ( l1,l2 ); if (l) l = s1 + (l-l1); delete[] l1; delete[] l2; return l; } #endif // ------------------------------------------------------- /* void ISwap ( int & x, int & y ) { int b; b = x; x = y; y = b; } void WSwap ( word & x, word & y ) { word b; b = x; x = y; y = b; } void BSwap ( byte & x, byte & y ) { byte b; b = x; x = y; y = b; } void LSwap ( long & x, long & y ) { long b; b = x; x = y; y = b; } void RSwap ( realtype & x, realtype & y ) { realtype b; b = x; x = y; y = b; } */ // ------------------------------------------------------- /* realtype RMax ( const realtype x1, const realtype x2 ) { return ( x1 > x2 ? x1 : x2 ); } long LMax ( const long x1, const long x2 ) { return ( x1 > x2 ? x1 : x2 ); } word WMax ( const word x1, const word x2 ) { return ( x1 > x2 ? x1 : x2 ); } int IMax ( const int x1, const int x2 ) { return ( x1 > x2 ? x1 : x2 ); } realtype RMin ( const realtype x1, const realtype x2 ) { return ( x1 < x2 ? x1 : x2 ); } long LMin ( const long x1, const long x2 ) { return ( x1 < x2 ? x1 : x2 ); } word WMin ( const word x1, const word x2 ) { return ( x1 < x2 ? x1 : x2 ); } int IMin ( const int x1, const int x2 ) { return ( x1 < x2 ? x1 : x2 ); } */ // ------------------------------------------------------- /* realtype fsign ( const realtype x1, const realtype x2 ) { realtype ax; if (x1>=0.0) ax = x1; else ax = -x1; return ( x2 >= 0.0 ? ax : -ax ); } */ // ------------------------------------------------------- Boolean GetVectorMemory ( rvector & V, word N, word Shift ) { V = new realtype[N]; if (V!=NULL) V = V - Shift; // shift for abovementioned enumeration return (V!=NULL); } Boolean GetVectorMemory ( ivector & I, word N, word Shift ) { I = new int[N]; if (I!=NULL) I = I - Shift; // shift for abovementioned enumeration return (I!=NULL); } Boolean GetVectorMemory ( wvector & W, word N, word Shift ) { W = new word[N]; if (W!=NULL) W = W - Shift; // shift for abovementioned enumeration return (W!=NULL); } Boolean GetVectorMemory ( bvector & B, word N, word Shift ) { B = new byte[N]; if (B!=NULL) B = B - Shift; // shift for abovementioned enumeration return (B!=NULL); } Boolean GetVectorMemory ( lvector & L, word N, word Shift ) { L = new long[N]; if (L!=NULL) L = L - Shift; // shift for abovementioned enumeration return (L!=NULL); } Boolean GetVectorMemory ( lwvector & L, word N, word Shift ) { L = new lword[N]; if (L!=NULL) L = L - Shift; // shift for abovementioned enumeration return (L!=NULL); } Boolean GetVectorMemory ( psvector & P, word N, word Shift ) { P = new pstr[N]; if (P!=NULL) P = P - Shift; // shift for abovementioned enumeration return (P!=NULL); } void FreeVectorMemory ( rvector & V, word Shift ) { if (V!=NULL) { V = V + Shift; // back shift for the work of heap system delete[] V; V = NULL; } } void FreeVectorMemory ( ivector & I, word Shift ) { if (I!=NULL) { I = I + Shift; // back shift for the work of heap system delete[] I; I = NULL; } } void FreeVectorMemory ( wvector & W, word Shift ) { if (W!=NULL) { W = W + Shift; // back shift for the work of heap system delete[] W; W = NULL; } } void FreeVectorMemory ( bvector & B, word Shift ) { if (B!=NULL) { B = B + Shift; // back shift for the work of heap system delete[] B; B = NULL; } } void FreeVectorMemory ( lvector & L, word Shift ) { if (L!=NULL) { L = L + Shift; // back shift for the work of heap system delete[] L; L = NULL; } } void FreeVectorMemory ( lwvector & L, word Shift ) { if (L!=NULL) { L = L + Shift; // back shift for the work of heap system delete[] L; L = NULL; } } void FreeVectorMemory ( psvector & P, word Shift ) { if (P!=NULL) { P = P + Shift; // back shift for the work of heap system delete[] P; P = NULL; } } Boolean GetMatrixMemory ( rmatrix & A, word N, word M, word ShiftN, word ShiftM ) { A = new rvector[N]; if (A!=NULL) { for (word i=0;i::epsilon(); } realtype floatMachinEps() { // A1.3.1 : Calculation of the machine's epsilon /* float fMachEps = 1.0; do fMachEps /= 2.0; while (float(1.0+fMachEps)!=1.0); return 2.0*fMachEps; */ return std::numeric_limits::epsilon(); } realtype frac ( realtype R ) { realtype i; return modf ( R,&i ); } long mod ( long x, long y ) { long k=x/y; long f=x-k*y; while (f<0) f += y; return f; } realtype Pow ( realtype X, int y ) { int m,l; realtype B; if (y==0) return 1.0; else if (X!=0.0) { B = X; m = 1; if (y>=0) l = y; else l = -y; while (m++=0) return B; else return 1.0/B; } else return 0.0; } realtype Pow1 ( realtype X, realtype Y ) { int k = mround(Y); if (fabs(k-Y)<=100.0*MachEps) return Pow(X,k); if (X==0.0) return 0.0; else return pow(X,Y); } realtype Exp ( realtype X ) { //realtype X1 = X; //realtype B = 1.0; if (X>=LnMaxRealExp) return MaxReal; else if (X<=LnMinRealExp) return 0.0; else { return exp(X); /* while (X1>LnMaxReal) { X1 -= LnMaxReal; B *= MaxExponent; } while (X1<-LnMaxReal) { X1 += LnMaxReal; B /= MaxExponent; } return B*exp(X1); */ } } Boolean Odd ( int i ) { return (i & 1); } // ---------------------------------------------------- long HexValL ( cpstr S ) { char C; int i; long z=0; for (i=0;S[i];i++) { z <<= 4; C = (char)toupper(S[i]); if (isdigit(C)) z += S[i]-'0'; else z += C-'A'+10; } return z; } // ---------------------------------------------------- long OctValL ( cpstr S ) { int i; long z=0; for (i=0;S[i];i++) { z <<= 3; z += S[i]-'0'; } return z; } // ---------------------------------------------------- long BinValL ( cpstr S ) { int i; long z=0; for (i=0;S[i];i++) { z <<= 1; z += S[i]-'0'; } return z; } pstr BinValS ( long L, pstr S ) { int i; long z; z = long(1) << (8*sizeof(long)-1); for (i=0;i<8*(int)sizeof(long);i++) { if (L & z) S[i] = '1'; else S[i] = '0'; z >>= 1; } S[8*sizeof(long)] = char(0); return S; } // ---------------------------------------------------- pstr ParamStr ( pstr D, cpstr S, realtype V, int M, cpstr S1 ) { char VS[30]; strcat ( D,S ); sprintf ( VS,"%-.*g",M,V ); strcat ( D,VS ); return strcat(D,S1); } pstr ParamStr ( pstr D, cpstr S, realtype V, int M, cpstr S1, realtype V2, int M2, cpstr S2 ) { char VS[30]; ParamStr ( D,S,V,M,S1 ); sprintf ( VS,"%-.*g",M2,V2 ); strcat ( D,VS ); return strcat(D,S2); } pstr CreateCopy ( pstr & Dest, cpstr Source ) { if (Dest) delete[] Dest; if (Source) { Dest = new char[strlen(Source)+1]; strcpy ( Dest,Source ); } else Dest = NULL; return Dest; } pstr CreateCopy_n ( pstr & Dest, cpstr Source, int n ) { int l; if (Dest) delete[] Dest; if (Source) { l = IMin ( strlen(Source),n ); Dest = new char[l+1]; strncpy ( Dest,Source,l ); Dest[l] = char(0); } else Dest = NULL; return Dest; } pstr CreateCopCat ( pstr & Dest, cpstr Source1, cpstr Source2, cpstr Source3, cpstr Source4, cpstr Source5 ) { if (Dest) { delete[] Dest; Dest = NULL; } return CreateConcat ( Dest,Source1,Source2,Source3,Source4,Source5 ); } pstr CreateCopCat ( pstr & Dest, cpstr Source1, cpstr Source2, cpstr Source3, cpstr Source4 ) { if (Dest) { delete[] Dest; Dest = NULL; } return CreateConcat ( Dest,Source1,Source2,Source3,Source4 ); } pstr CreateCopCat ( pstr & Dest, cpstr Source1, cpstr Source2, cpstr Source3 ) { if (Dest) { delete[] Dest; Dest = NULL; } return CreateConcat ( Dest,Source1,Source2,Source3 ); } pstr CreateCopCat ( pstr & Dest, cpstr Source1, cpstr Source2 ) { if (Dest) { delete[] Dest; Dest = NULL; } return CreateConcat ( Dest,Source1,Source2 ); } pstr CreateConcat ( pstr & Dest, cpstr Source1, cpstr Source2, cpstr Source3, cpstr Source4, cpstr Source5 ) { pstr S; int ld,ls; if (Dest) ld = strlen(Dest); else ld = 0; ls = 0; if (Source1) ls += strlen(Source1); if (Source2) ls += strlen(Source2); if (Source3) ls += strlen(Source3); if (Source4) ls += strlen(Source4); if (Source5) ls += strlen(Source5); if (ls>0) { S = new char[ls+ld+1]; if (Dest) { strcpy ( S,Dest ); delete[] Dest; } else S[0] = char(0); if (Source1) strcat ( S,Source1 ); if (Source2) strcat ( S,Source2 ); if (Source3) strcat ( S,Source3 ); if (Source4) strcat ( S,Source4 ); if (Source5) strcat ( S,Source5 ); Dest = S; } return Dest; } pstr CreateConcat ( pstr & Dest, cpstr Source1, cpstr Source2, cpstr Source3, cpstr Source4 ) { pstr S; int ld,ls; if (Dest) ld = strlen(Dest); else ld = 0; ls = 0; if (Source1) ls += strlen(Source1); if (Source2) ls += strlen(Source2); if (Source3) ls += strlen(Source3); if (Source4) ls += strlen(Source4); if (ls>0) { S = new char[ls+ld+1]; if (Dest) { strcpy ( S,Dest ); delete[] Dest; } else S[0] = char(0); if (Source1) strcat ( S,Source1 ); if (Source2) strcat ( S,Source2 ); if (Source3) strcat ( S,Source3 ); if (Source4) strcat ( S,Source4 ); Dest = S; } return Dest; } pstr CreateConcat ( pstr & Dest, cpstr Source1, cpstr Source2, cpstr Source3 ) { pstr S; int ld,ls; if (Dest) ld = strlen(Dest); else ld = 0; ls = 0; if (Source1) ls += strlen(Source1); if (Source2) ls += strlen(Source2); if (Source3) ls += strlen(Source3); if (ls>0) { S = new char[ls+ld+1]; if (Dest) { strcpy ( S,Dest ); delete[] Dest; } else S[0] = char(0); if (Source1) strcat ( S,Source1 ); if (Source2) strcat ( S,Source2 ); if (Source3) strcat ( S,Source3 ); Dest = S; } return Dest; } pstr CreateConcat ( pstr & Dest, cpstr Source1, cpstr Source2 ) { pstr S; int ld,ls; if (Dest) ld = strlen(Dest); else ld = 0; ls = 0; if (Source1) ls += strlen(Source1); if (Source2) ls += strlen(Source2); if (ls>0) { S = new char[ls+ld+1]; if (Dest) { strcpy ( S,Dest ); delete[] Dest; } else S[0] = char(0); if (Source1) strcat ( S,Source1 ); if (Source2) strcat ( S,Source2 ); Dest = S; } return Dest; } pstr CreateConcat ( pstr & Dest, cpstr Source ) { pstr S; int ld,ls; if (Dest) ld = strlen(Dest); else ld = 0; if (Source) ls = strlen(Source); else ls = 0; if (ls>0) { S = new char[ls+ld+1]; if (Dest) { strcpy ( S,Dest ); delete[] Dest; } else S[0] = char(0); strcat ( S,Source ); Dest = S; } return Dest; } pstr LastOccurence ( cpstr S, char c ) { pstr P=(pstr)S; pstr R=NULL; while (*P) { if (*P==c) R = P; P++; } return R; } pstr FirstOccurence ( cpstr S, char c ) { pstr P=(pstr)S; while (*P) { if (*P==c) return P; P++; } return NULL; } int indexOf ( cpstr S, char c ) { int i=0; while (S[i]) { if (S[i]==c) return i; i++; } return -1; } pstr FirstOccurence ( cpstr S, int Slen, cpstr Q, int Qlen ) { int i,j,k,l; l = Slen-Qlen; for (i=0;i<=l;i++) { j = 0; k = i; while (j=Qlen) return pstr(&(S[i])); } return NULL; } int indexOf ( cpstr S, int Slen, cpstr Q, int Qlen ) { int i,j,k,l; l = Slen-Qlen; for (i=0;i<=l;i++) { j = 0; k = i; while (j=Qlen) return i; } return -1; } pstr LowerCase ( pstr s ) { pstr p=s; while (*p) { *p = char(tolower(int(*p))); p++; } return s; } pstr UpperCase ( pstr s ) { pstr p=s; while (*p) { *p = char(toupper(int(*p))); p++; } return s; } void GetString ( pstr L, cpstr S, int M ) { // Copies first M characters of string S into string L, // appending the terminating null. If S contains less // then M characters, L will be padded with spaces. int i,j; i = 0; j = 0; while (S[i] && (i=SMax) || (!S[k])) { lm1 = IMin(n,lm1); while (k=SMax)) { lm1 = IMin(n,lm1); while (k=0) && (k>=0)) d[i--] = s[k--]; while (i>=0) d[i--] = ' '; } void strcpy_nr ( pstr d, cpstr s, int n ) { // Copies at most n symbols from string s to d, but // no more than strlen(s) (s must contain a terminating null). // The string in d is aligned to the right and added with // spaces at the left, if necessary. The terminating null // IS NEITHER appended NOR copied to d. int i,k; i = n-1; k = IMin(i,strlen(s)-1); while ((i>=0) && (k>=0)) d[i--] = s[k--]; while (i>=0) d[i--] = ' '; } void strcpy_ns ( pstr d, cpstr s, int n ) { // Copies at most n symbols from string s to d, but // no more than strlen(s) (s must contain a terminating // null). The terminating null IS NEITHER appended NOR // copied to d; rather, d is padded with spaces if // strlen(s)0) && (d[i]==' ')) i--; if (d[i]==' ') d[i] = char(0); else d[i+1] = char(0); return d; } pstr strcpy_ncs ( pstr d, cpstr s, int n ) { // Copies at most n characters from string s to string d // cutting all spaces at at the end. Thus, " abcde " will // be copied like " abc" at n=4 and like " abcde" at n>5 // (terminating null appended). // The function returns d. int i; i = 0; while (s[i] && (i0) && (d[i]==' ')) i--; if (d[i]==' ') d[i] = char(0); else d[i+1] = char(0); return d; } pstr strcpy_css ( pstr d, cpstr s ) { // Copies string s to string d cutting all spaces at // at the begining and at the end. Thus, " ab c de " // will be copied like "ab c de" (terminating null // appended). // The function returns d. int i,k; i = 0; while (s[i]==' ') i++; k = 0; while (s[i]) d[k++] = s[i++]; if (k>0) { k--; while ((k>0) && (d[k]==' ')) k--; if (d[k]==' ') d[k] = char(0); else d[k+1] = char(0); } else d[k] = char(0); return d; } pstr strcpy_ncss ( pstr d, cpstr s, int n ) { // Copies at most n characters from string s to string d cutting // all spaces at the begining and at the end. Thus, " ab c de " // will be copied like "ab" at n=3 (terminating null appended). // The function returns d. int i,k; i = 0; while ((s[i]==' ') && (i0) { k--; while ((k>0) && (d[k]==' ')) k--; if (d[k]==' ') d[k] = char(0); else d[k+1] = char(0); } else d[k] = char(0); return d; } pstr strcpy_n0 ( pstr d, cpstr s, int n ) { // Copies at most n symbols from string s to d, but // no more than strlen(s) (s must contain a terminating // null). The terminating null IS appended to d. // The function returns d. int i; i = 0; while ((i0)) { k--; while ((k>0) && (S[k]==' ')) k--; if (S[k]!=' ') k++; } S[k] = char(0); return S; } pstr DelSpaces ( pstr S, char c ) { // Removes all spaces (or other symbols as specified by 'c') // from the string. The string is then shrinked by the number // of removed characters. Thus, " as ttt " becomes "asttt". int i,j; j = 0; for (i=0;S[i];i++) if (S[i]!=c) { if (j=0;j--) { n = (I >> sh) & 0xFF; iUB[j] = byte(n); sh -= 8; } } */ void int2UniBin ( int I, intUniBin iUB ) { int n; word j; n = I; for (j=0;j>= 8; } } void short2UniBin ( short S, shortUniBin sUB ) { int j,sh; short n; sh = 8*(sizeof(shortUniBin)-1); for (j=sizeof(shortUniBin)-1;j>=0;j--) { n = (S >> sh) & 0xFF; sUB[j] = byte(n); sh -= 8; } } void long2UniBin ( long L, longUniBin lUB ) { int j,sh; long n; sh = 8*(sizeof(longUniBin)-1); for (j=sizeof(longUniBin)-1;j>=0;j--) { n = (L >> sh) & 0xFF; lUB[j] = byte(n); sh -= 8; } } void word2UniBin ( word W, wordUniBin wUB ) { int j,sh; word n; sh = 8*(sizeof(wordUniBin)-1); for (j=sizeof(wordUniBin)-1;j>=0;j--) { n = (W >> sh) & 0xFF; wUB[j] = byte(n); sh -= 8; } } void real2UniBin ( realtype R, realUniBin rUB ) { int k1,k2,k; realtype Q,L; if (R>=0) Q = R; else Q = -R; k1 = 0; k2 = _nfPowers; do { k = (k1+k2)/2; if (Q>=_fpower[k]) k1 = k; else k2 = k; } while (k2>k1+1); if (Q<=_fpower[0]) k2 = 0; Q = (Q/_fpower[k2])*_fpower8; rUB[0] = byte(k2); for (k=sizeof(realUniBin)-1;k>0;k--) { L = floor(Q/_rfbase); rUB[k] = byte(int(Q-L*_rfbase)); Q = L; } if (R<0) rUB[1] |= _fsign; } void shortreal2UniBin ( shortreal R, shortrealUniBin srUB ) { int k1,k2,k; realtype Q,L; if (R>=0) Q = R; else Q = -R; k1 = 0; k2 = _nfPowers; do { k = (k1+k2)/2; if (Q>=_fpower[k]) k1 = k; else k2 = k; } while (k2>k1+1); if (Q<=_fpower[0]) k2 = 0; Q = (Q/_fpower[k2])*_fpower4; srUB[0] = byte(k2); for (k=sizeof(shortrealUniBin)-1;k>0;k--) { L = floor(Q/_rfbase); srUB[k] = byte(int(Q-L*_rfbase)); Q = L; } if (R<0) srUB[1] |= _fsign; } /* #undef _new_float_unibin #ifdef _new_float_unibin void float2UniBin ( realtype R, floatUniBin fUB ) { int k1,k2,k; realtype Q,L; if (R>=0) Q = R; else Q = -R; k1 = 0; k2 = _nfPowers; do { k = (k1+k2)/2; if (Q>=_fpower[k]) k1 = k; else k2 = k; } while (k2>k1+1); if (Q<=_fpower[0]) k2 = 0; Q = (Q/_fpower[k2])*_fpower4; fUB[0] = byte(k2); for (k=sizeof(floatUniBin)-1;k>0;k--) { L = floor(Q/_rfbase); fUB[k] = byte(int(Q-L*_rfbase)); Q = L; } if (R<0) fUB[1] |= _fsign; } #else void float2UniBin ( realtype R, floatUniBin fUB ) { int k1,k2,k; realtype Q,L; if (R>=0) Q = R; else Q = -R; k1 = 0; k2 = _nfPowers; do { k = (k1+k2)/2; if (Q>=_fpower[k]) k1 = k; else k2 = k; } while (k2>k1+1); if (Q<=_fpower[0]) k2 = 0; Q = (Q/_fpower[k2])*_fpower8; fUB[0] = byte(k2); for (k=sizeof(realUniBin)-1;k>0;k--) { L = floor(Q/_rfbase); if (k<=sizeof(floatUniBin)) fUB[k] = byte(int(Q-L*_rfbase)); Q = L; } if (R<0) fUB[1] |= _fsign; } #endif */ void float2UniBin ( realtype R, floatUniBin fUB ) { int k1,k2,k; realtype Q,L; if (R>=0) Q = R; else Q = -R; k1 = 0; k2 = _nfPowers; do { k = (k1+k2)/2; if (Q>=_fpower[k]) k1 = k; else k2 = k; } while (k2>k1+1); if (Q<=_fpower[0]) k2 = 0; fUB[0] = byte(k2); if (_old_float_unibin) { // this is wrong but compatible with already existing files :( // in the result, it gives errors in 6th digit at back conversion Q = (Q/_fpower[k2])*_fpower8; for (k=sizeof(realUniBin)-1;k>0;k--) { L = floor(Q/_rfbase); if (k<=(int)sizeof(floatUniBin)) fUB[k] = byte(int(Q-L*_rfbase)); Q = L; } } else { // this is correct Q = (Q/_fpower[k2])*_fpower4; for (k=sizeof(floatUniBin)-1;k>0;k--) { L = floor(Q/_rfbase); fUB[k] = byte(int(Q-L*_rfbase)); Q = L; } } //if (fUB[1] & _fsign) printf ( " error!\n" ); if (R<0) fUB[1] |= _fsign; } void UniBin2float ( floatUniBin fUB, realtype & R ) { int j,s; if (fUB[1] & _fsign) { s = 1; fUB[1] &= _fsign1; } else s = 0; R = int(fUB[1]); if (_old_float_unibin) { // this is wrong and gives a conversion error in 6th digit :( // we have to keep this for compatibility with already existing // files for (j=2;j<(int)sizeof(floatUniBin);j++) R = R*_rfbase + int(fUB[j]); for (j=sizeof(floatUniBin);j<(int)sizeof(realUniBin);j++) R *= _rfbase; R = (R/_fpower8)*_fpower[int(fUB[0])]; } else { // this is correct for (j=2;j<(int)sizeof(floatUniBin);j++) R = R*_rfbase + int(fUB[j]); R = (R/_fpower4)*_fpower[int(fUB[0])]; } if (s) R = -R; } /* ------------------------------------------------------- This piece of code shows that float2Unibin - Unbin2float pair does same-quality job as the native float - double conversion: InitMatType(); set_new_float_unibin(); floatUniBin fUB; realUniBin rUB; realtype maxsh = MaxShortReal/2.0; // max manageable /2! float maxshf = maxsh; realtype maxshr = maxshf; realtype maxsh1; float2UniBin ( maxsh,fUB ); UniBin2float ( fUB,maxsh1 ); printf ( " float\n %10.3f\n %10.3f\n %10.3f\n %10.3f\n", maxsh,maxsh1,maxshf,maxshr ); maxsh = MaxShortReal; real2UniBin ( maxsh,rUB ); UniBin2real ( rUB,maxsh1 ); printf ( " real\n %10.3f\n %10.3f\n",maxsh,maxsh1 ); ---- RESULTS: float 170099999999999990938343446679146987520.000 170099999948540854500627141228603899904.000 170100000027769017014891478822147850240.000 170100000027769017014891478822147850240.000 real 340199999999999981876686893358293975040.000 340199999999999981876686893358293975040.000 -------------------------------------------------------------- */ /* void shortreal2UniBin ( shortreal R, shortrealUniBin srUB ) { int k1,k2,k; realtype Q,L; if (R>=0) Q = R; else Q = -R; k1 = 0; k2 = _nfPowers; do { k = (k1+k2)/2; if (Q>=_fpower[k]) k1 = k; else k2 = k; } while (k2>k1+1); if (Q<=_fpower[0]) k2 = 0; Q = (Q/_fpower[k2])*_fpower8; srUB[0] = byte(k2); for (k=sizeof(realUniBin)-1;k>0;k--) { L = floor(Q/_rfbase); if (k<=(int)sizeof(shortrealUniBin)) srUB[k] = byte(int(Q-L*_rfbase)); Q = L; } if (R<0) srUB[1] |= _fsign; } void float2UniBin ( realtype R, floatUniBin fUB ) { int k1,k2,k; realtype Q,L; if (R>=0) Q = R; else Q = -R; k1 = 0; k2 = _nfPowers; do { k = (k1+k2)/2; if (Q>=_fpower[k]) k1 = k; else k2 = k; } while (k2>k1+1); if (Q<=_fpower[0]) k2 = 0; Q = (Q/_fpower[k2])*_fpower8; fUB[0] = byte(k2); for (k=sizeof(realUniBin)-1;k>0;k--) { L = floor(Q/_rfbase); if (k<=(int)sizeof(floatUniBin)) fUB[k] = byte(int(Q-L*_rfbase)); Q = L; } if (R<0) fUB[1] |= _fsign; } */ /* void UniBin2int ( intUniBin iUB, int & I ) { int j,n,sh; sh = 8*sizeof(intUniBin); I = 0x00; for (j=sizeof(intUniBin)-1;j>=0;j--) { sh -= 8; n = byte(iUB[j]); I = I | (n << sh); } } */ void UniBin2int ( intUniBin iUB, int & I ) { int j; I = 0x00; for (j=sizeof(intUniBin)-1;j>=0;j--) { I <<= 8; I |= int(iUB[j]); } } void UniBin2short ( shortUniBin sUB, short & S ) { int j,sh; short n; sh = 8*sizeof(shortUniBin); S = 0x00; for (j=sizeof(shortUniBin)-1;j>=0;j--) { sh -= 8; n = byte(sUB[j]); S = S | (n << sh); } } void UniBin2long ( longUniBin lUB, long & L ) { int j,sh; long n; sh = 8*sizeof(longUniBin); L = 0x00; for (j=sizeof(longUniBin)-1;j>=0;j--) { sh -= 8; n = byte(lUB[j]); L = L | (n << sh); } } void UniBin2word ( wordUniBin wUB, word & W ) { int j,sh; word n; sh = 8*sizeof(wordUniBin); W = 0x00; for (j=sizeof(wordUniBin)-1;j>=0;j--) { sh -= 8; n = byte(wUB[j]); W = W | (n << sh); } } void UniBin2real ( realUniBin rUB, realtype & R ) { int j,s; if (rUB[1] & _fsign) { s = 1; rUB[1] &= _fsign1; } else s = 0; R = int(rUB[1]); for (j=2;j<(int)sizeof(realUniBin);j++) R = R*_rfbase + int(rUB[j]); R = (R/_fpower8)*_fpower[int(rUB[0])]; if (s) R = -R; } void UniBin2shortreal ( shortrealUniBin srUB, shortreal & R ) { int j,s; if (srUB[1] & _fsign) { s = 1; srUB[1] &= _fsign1; } else s = 0; R = int(srUB[1]); for (j=2;j<(int)sizeof(shortrealUniBin);j++) R = R*_rfbase + int(srUB[j]); R = (R/_fpower4)*_fpower[int(srUB[0])]; if (s) R = -R; } /* #ifdef _new_float_unibin void UniBin2float ( floatUniBin fUB, realtype & R ) { int j,s; if (fUB[1] & _fsign) { s = 1; fUB[1] &= _fsign1; } else s = 0; R = int(fUB[1]); for (j=2;j<(int)sizeof(floatUniBin);j++) R = R*_rfbase + int(fUB[j]); R = (R/_fpower4)*_fpower[int(fUB[0])]; if (s) R = -R; } #else void UniBin2float ( floatUniBin fUB, realtype & R ) { int j,s; if (fUB[1] & _fsign) { s = 1; fUB[1] &= _fsign1; } else s = 0; R = int(fUB[1]); for (j=2;j0) { memcpy ( &(S[l]),L,len ); l += len; S[l] = char(0); } } void mem_write ( Boolean B, pstr S, int & l ) { if (B) S[l++] = 'Y'; else S[l++] = 'N'; S[l] = char(0); } void mem_write_byte ( byte B, pstr S, int & l ) { S[l++] = char(B); S[l] = char(0); } void mem_read ( int & I, cpstr S, int & l ) { intUniBin iUB; memcpy ( iUB,&(S[l]),sizeof(intUniBin) ); l += sizeof(intUniBin); UniBin2int ( iUB,I ); } void mem_read ( short & I, cpstr S, int & l ) { shortUniBin sUB; memcpy ( sUB,&(S[l]),sizeof(shortUniBin) ); l += sizeof(shortUniBin); UniBin2short ( sUB,I ); } void mem_read ( long & I, cpstr S, int & l ) { longUniBin lUB; memcpy ( lUB,&(S[l]),sizeof(longUniBin) ); l += sizeof(longUniBin); UniBin2long ( lUB,I ); } void mem_read ( word & W, cpstr S, int & l ) { wordUniBin wUB; memcpy ( wUB,&(S[l]),sizeof(wordUniBin) ); l += sizeof(wordUniBin); UniBin2word ( wUB,W ); } void mem_read ( realtype & R, cpstr S, int & l ) { realUniBin rUB; memcpy ( rUB,&(S[l]),sizeof(realUniBin) ); l += sizeof(realUniBin); UniBin2real ( rUB,R ); } void mem_read ( shortreal & R, cpstr S, int & l ) { shortrealUniBin srUB; memcpy ( srUB,&(S[l]),sizeof(shortrealUniBin) ); l += sizeof(shortrealUniBin); UniBin2shortreal ( srUB,R ); } void mem_read ( pstr L, int len, cpstr S, int & l ) { memcpy ( L,&(S[l]),len ); l += len; } void mem_read ( pstr & L, cpstr S, int & l ) { int len; if (L) { delete[] L; L = NULL; } mem_read ( len,S,l ); if (len>0) { L = new char[len+1]; memcpy ( L,&(S[l]),len ); L[len] = char(0); l += len; } } void mem_read ( Boolean & B, cpstr S, int & l ) { B = (S[l++]=='Y'); } void mem_read_byte ( byte & B, cpstr S, int & l ) { B = byte(S[l++]); } // ------------------------------------------------------- Boolean InitMatType() { MachEps = MachinEps(); floatMachEps = floatMachinEps(); LnMaxReal = log(fMaxReal); LnMinReal = log(fMinReal); LnMaxRealExp = LnMaxReal; LnMinRealExp = LnMinReal; InitFPowers(); return True; } /* =================================================== */ // *** end of mmdb-1.25.5/mmdb/mmdb_utils.cpp0000775000175000017500000014570712162051331013243 00000000000000// $Id: mmdb_utils.cpp,v 1.32 2012/01/26 17:52:21 ekr Exp $ // ================================================================= // // CCP4 Coordinate Library: support of coordinate-related // functionality in protein crystallography applications. // // Copyright (C) Eugene Krissinel 2000-2008. // // This library is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // // ================================================================= // // 14.06.13 <-- Date of Last Modification. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ----------------------------------------------------------------- // // **** Module : MMDB_Utils // ~~~~~~~~~ // **** Project : MacroMolecular Data Base (MMDB) // ~~~~~~~~~ // // **** Classes : CContainerClass ( containered class template ) // ~~~~~~~~~ CContString ( containered string ) // CClassContainer ( container of classes ) // CAtomPath ( atom path ID ) // CQuickSort ( quick sort of integers ) // // **** Functions : Date9to11 ( DD-MMM-YY -> DD-MMM-YYYY ) // ~~~~~~~~~~~ Date11to9 ( DD-MMM-YYYY -> DD-MMM-YY ) // Date9toCIF ( DD-MMM-YY -> YYYY-MM-DD ) // Date11toCIF( DD-MMM-YYYY -> YYYY-MM-DD ) // DateCIFto9 ( YYYY-MM-DD -> DD-MMM-YY ) // DateCIFto11( YYYY-MM-DD -> DD-MMM-YYYY ) // GetInteger ( reads integer from a string ) // GetReal ( reads real from a string ) // GetIntIns ( reads integer and insert code ) // PutInteger ( writes integer into a string ) // PutRealF ( writes real in F-foram into a string) // PutIntIns ( writes integer and insert code ) // CIFGetInteger ( reads and deletes int from CIF ) // CIFGetReal ( reads and deletes real from CIF ) // CIFGetString (reads and deletes string from CIF) // CIFGetInteger1 (reads and del-s int from CIF loop) // CIFGetReal1 (reads and del-s int from CIF loop) // Mat4Inverse ( inversion of 4x4 matrices ) // GetErrorDescription (ascii line to an Error_XXXXX) // ParseAtomID ( parses atom ID line ) // ParseResID ( parses residue ID line ) // ParseAtomPath ( parses full atom path ) // // (C) E. Krissinel 2000-2013 // // ================================================================= // #ifndef __STRING_H #include #endif #ifndef __MATH_H #include #endif #ifndef __STDLIB_H #include #endif #ifndef __MMDB_Utils__ #include "mmdb_utils.h" #endif #ifndef IOTBX_PDB_HYBRID_36_C_H #include "hybrid_36.h" #endif // ====================== Date functions ======================= static cpstr Month[12] = { "JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC" }; static cpstr nMonth[12] = { "01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12" }; void Date9to11 ( cpstr Date9, pstr Date11 ) { // converts DD-MMM-YY to DD-MMM-YYYY int i; i = 0; while ((i<12) && (strncmp(Month[i],&(Date9[3]),3))) i++; if (i<12) { // DD-MMM-YY -> DD-MMM-YYYY strncpy ( Date11,Date9,7 ); if (Date9[7]!='0') strncpy ( &(Date11[7]),"19",2 ); else strncpy ( &(Date11[7]),"20",2 ); strncpy ( &(Date11[9]),&(Date9[7]),2 ); } else { // DD-MM-YY -> DD-MMM-YYYY strncpy ( Date11,Date9,3 ); i = 0; while ((i<12) && (strncmp(nMonth[i],&(Date9[3]),2))) i++; if (i<12) strncpy ( &(Date11[3]),Month[i],3 ); else { strncpy ( &(Date11[3]),&(Date9[3]),2 ); Date11[5] = 'X'; } if (Date9[6]!='0') strncpy ( &(Date11[7]),"19",2 ); else strncpy ( &(Date11[7]),"20",2 ); strncpy ( &(Date11[9]),&(Date9[6]),2 ); } Date11[2] = '-'; Date11[6] = '-'; Date11[11] = char(0); } void Date11to9 ( cpstr Date11, pstr Date9 ) { // converts DD-MMM-YYYY to DD-MMM-YY int i; i = 0; while ((i<12) && (strncmp(Month[i],&(Date11[3]),3))) i++; if (i<12) { // DD-MMM-YYYY -> DD-MMM-YY strncpy ( Date9,Date11,7 ); strncpy ( &(Date9[7]),&(Date11[9]),2 ); } else { // DD-MM-YYYY -> DD-MMM-YY strncpy ( Date9,Date11,3 ); i = 0; while ((i<12) && (strncmp(nMonth[i],&(Date11[3]),2))) i++; if (i<12) strncpy ( &(Date9[3]),Month[i],3 ); else { strncpy ( &(Date9[3]),&(Date11[3]),2 ); Date9[5] = 'X'; } strncpy ( &(Date9[7]),&(Date11[8]),2 ); } Date9[2] = '-'; Date9[6] = '-'; } void Date9toCIF ( cpstr Date9, pstr DateCIF ) { // DD-MMM-YY -> YYYY-MM-DD ) int i; i = 0; while ((i<12) && (strncmp(Month[i],&(Date9[3]),3))) i++; if (i<12) { // DD-MMM-YY -> YYYY-MM-DD if (Date9[7]!='0') strcpy ( DateCIF,"19" ); else strcpy ( DateCIF,"20" ); strncpy ( &(DateCIF[2]),&(Date9[7]),2 ); strncpy ( &(DateCIF[5]),nMonth[i],2 ); } else { // DD-MM-YY -> YYYY-MM-DD if (Date9[6]!='0') strcpy ( DateCIF,"19" ); else strcpy ( DateCIF,"20" ); strncpy ( &(DateCIF[2]),&(Date9[6]),2 ); strncpy ( &(DateCIF[5]),&(Date9[3]),2 ); } DateCIF[4] = '-'; DateCIF[7] = '-'; strncpy ( &(DateCIF[8]),Date9,2 ); DateCIF[10] = char(0); } void Date11toCIF ( cpstr Date11, pstr DateCIF ) { // DD-MMM-YYYY -> YYYY-MM-DD int i; i = 0; while ((i<12) && (strncmp(Month[i],&(Date11[3]),3))) i++; if (i<12) { strncpy ( DateCIF,&(Date11[7]),4 ); strncpy ( &(DateCIF[5]),nMonth[i],2 ); } else { strncpy ( DateCIF,&(Date11[6]),4 ); strncpy ( &(DateCIF[5]),&(Date11[3]),2 ); } DateCIF[4] = '-'; DateCIF[7] = '-'; strncpy ( &(DateCIF[8]),Date11,2 ); DateCIF[10] = char(0); } void DateCIFto9 ( cpstr DateCIF, pstr Date9 ) { // YYYY-MM-DD -> DD-MMM-YY int i; strncpy ( Date9,&(DateCIF[8]),2 ); Date9[2] = '-'; i = 0; while ((i<12) && (strncmp(nMonth[i],&(DateCIF[5]),2))) i++; if (i<12) strncpy ( &(Date9[3]),Month[i],3 ); else { strncpy ( &(Date9[3]),&(DateCIF[5]),2 ); Date9[5] = 'X'; } Date9[6] = '-'; strncpy ( &(Date9[7]),&(DateCIF[2]),2 ); // DateCIF[9] = char(0); } void DateCIFto11 ( cpstr DateCIF, pstr Date11 ) { // YYYY-MM-DD -> DD-MMM-YYYY int i; strncpy ( Date11,&(DateCIF[8]),2 ); Date11[2] = '-'; i = 0; while ((i<12) && (strncmp(nMonth[i],&(DateCIF[5]),2))) i++; if (i<12) strncpy ( &(Date11[3]),Month[i],3 ); else { strncpy ( &(Date11[3]),&(DateCIF[5]),2 ); Date11[5] = 'X'; } Date11[6] = '-'; strncpy ( &(Date11[7]),DateCIF,4 ); // DateCIF[11] = char(0); } // =============== Format functions =================== Boolean GetInteger ( int & N, cpstr S, int M ) { // Returns True if S contains an integer number in its // first M characters. This number is returned in N. // The return is False if no integer number may be // recognized. In this case, N is assigned MinInt4 value. pstr endptr; char L[50]; strncpy ( L,S,M ); L[M] = char(0); N = mround(strtod(L,&endptr)); if ((N==0) && (endptr==L)) { N = MinInt4; // no number return False; } else return True; } Boolean GetReal ( realtype & R, cpstr S, int M ) { // Returns True if S contains a real number in its // first M characters. This number is returned in R. // The return is False if no real number may be // recognized. In this case, R is assigned -MaxReal value. pstr endptr; char L[50]; strncpy ( L,S,M ); L[M] = char(0); R = strtod(L,&endptr); if ((R==0.0) && (endptr==L)) { R = -MaxReal; // no number return False; } else return True; } Boolean GetIntIns ( int & N, pstr ins, cpstr S, int M ) { // Returns True if S contains an integer number in its // first M characters. This number is returned in N. In addition // to that, GetIntIns() retrieves the insertion code which may // follow the integer and returns it in "ins" (1 character + // terminating 0). // The return is False if no integer number may be // recognized. In this case, N is assigned MinInt4 value, // "ins" just returns (M+1)th symbol of S (+terminating 0). pstr endptr; char L[50]; if (S[M]!=' ') { ins[0] = S[M]; ins[1] = char(0); } else ins[0] = char(0); strncpy ( L,S,M ); L[M] = char(0); if ((M==4) && ((S[0]>='A') || ((S[0]=='-') && (S[1]>='A')))) hy36decode ( M,L,M,&N); else { endptr = NULL; N = mround(strtod(L,&endptr)); if ((N==0) && (endptr==L)) { N = MinInt4; // no number return False; } } return True; } void PutInteger ( pstr S, int N, int M ) { // Integer N is converted into ASCII string of length M // and pasted onto first M characters of string S. No // terminating zero is added. // If N is set to MinInt4, then first M characters of // string S are set to the space character. int i; char L[50]; if (N==MinInt4) for (i=0;iGetInteger ( I,Tag,Signal,True ); if (RC==CIFRC_WrongFormat) { F = Loop->GetString ( Tag,Signal,RC ); if (F) sprintf ( CIFErrorLocation,"loop %s.%s row %i data %s", Loop->GetCategoryName(),Tag,Signal,F ); else sprintf ( CIFErrorLocation,"loop %s.%s row %i data [NULL]", Loop->GetCategoryName(),Tag,Signal ); Signal = -Error_UnrecognizedInteger-1; return Error_UnrecognizedInteger; } if (RC==CIFRC_WrongIndex) { Signal = -1; return Error_NoData; } if (RC) { F = Loop->GetString ( Tag,Signal,RC ); if (F) sprintf ( CIFErrorLocation,"loop %s.%s row %i data %s", Loop->GetCategoryName(),Tag,Signal,F ); else sprintf ( CIFErrorLocation,"loop %s.%s row %i data [NULL]", Loop->GetCategoryName(),Tag,Signal ); Signal = -Error_NoData-1; return Error_NoData; } return 0; } int CIFGetInteger1 ( int & I, PCMMCIFLoop Loop, cpstr Tag, int nrow ) { int RC; pstr F; RC = Loop->GetInteger ( I,Tag,nrow,True ); if (RC==CIFRC_WrongFormat) { F = Loop->GetString ( Tag,nrow,RC ); if (F) sprintf ( CIFErrorLocation,"loop %s.%s row %i data %s", Loop->GetCategoryName(),Tag,nrow,F ); else sprintf ( CIFErrorLocation,"loop %s.%s row %i data [NULL]", Loop->GetCategoryName(),Tag,nrow ); return Error_UnrecognizedInteger; } if (RC==CIFRC_WrongIndex) return Error_NoData; if (RC) { F = Loop->GetString ( Tag,nrow,RC ); if (F) sprintf ( CIFErrorLocation,"loop %s.%s row %i data %s", Loop->GetCategoryName(),Tag,nrow,F ); else sprintf ( CIFErrorLocation,"loop %s.%s row %i data [NULL]", Loop->GetCategoryName(),Tag,nrow ); return Error_NoData; } return 0; } int CIFGetReal ( realtype & R, PCMMCIFLoop Loop, cpstr Tag, int & Signal ) { int RC; pstr F; RC = Loop->GetReal ( R,Tag,Signal,True ); if (RC==CIFRC_WrongFormat) { F = Loop->GetString ( Tag,Signal,RC ); if (F) sprintf ( CIFErrorLocation,"loop %s.%s row %i data %s", Loop->GetCategoryName(),Tag,Signal,F ); else sprintf ( CIFErrorLocation,"loop %s.%s row %i data [NULL]", Loop->GetCategoryName(),Tag,Signal ); Signal = -Error_UnrecognizedReal-1; return Error_UnrecognizedReal; } if (RC==CIFRC_WrongIndex) { Signal = -1; return Error_NoData; } if (RC) { F = Loop->GetString ( Tag,Signal,RC ); if (F) sprintf ( CIFErrorLocation,"loop %s.%s row %i data %s", Loop->GetCategoryName(),Tag,Signal,F ); else sprintf ( CIFErrorLocation,"loop %s.%s row %i data [NULL]", Loop->GetCategoryName(),Tag,Signal ); Signal = -Error_NoData-1; return Error_NoData; } return 0; } int CIFGetReal1 ( realtype & R, PCMMCIFLoop Loop, cpstr Tag, int nrow ) { int RC; pstr F; RC = Loop->GetReal ( R,Tag,nrow,True ); if (RC==CIFRC_WrongFormat) { F = Loop->GetString ( Tag,nrow,RC ); if (F) sprintf ( CIFErrorLocation,"loop %s.%s row %i data %s", Loop->GetCategoryName(),Tag,nrow,F ); else sprintf ( CIFErrorLocation,"loop %s.%s row %i data [NULL]", Loop->GetCategoryName(),Tag,nrow ); return Error_UnrecognizedReal; } if (RC==CIFRC_WrongIndex) return Error_NoData; if (RC) { F = Loop->GetString ( Tag,nrow,RC ); if (F) sprintf ( CIFErrorLocation,"loop %s.%s row %i data %s", Loop->GetCategoryName(),Tag,nrow,F ); else sprintf ( CIFErrorLocation,"loop %s.%s row %i data [NULL]", Loop->GetCategoryName(),Tag,nrow ); return Error_NoData; } return 0; } int CIFGetString ( pstr S, PCMMCIFLoop Loop, cpstr Tag, int row, int SLen, cpstr DefS ) { int RC; pstr F; F = Loop->GetString ( Tag,row,RC ); if ((!RC) && F) { strncpy ( S,F,SLen-1 ); Loop->DeleteField ( Tag,row ); return 0; } else { strcpy ( S,DefS ); return 1; } } int CIFGetInteger ( int & I, PCMMCIFStruct Struct, cpstr Tag, Boolean Remove ) { int RC; pstr F; RC = Struct->GetInteger ( I,Tag,Remove ); if (RC==CIFRC_WrongFormat) { F = Struct->GetString ( Tag,RC ); if (F) sprintf ( CIFErrorLocation,"structure %s.%s data %s", Struct->GetCategoryName(),Tag,F ); else sprintf ( CIFErrorLocation,"structure %s.%s data [NULL]", Struct->GetCategoryName(),Tag ); return Error_UnrecognizedInteger; } if (RC) { F = Struct->GetString ( Tag,RC ); if (F) sprintf ( CIFErrorLocation,"structure %s.%s data %s", Struct->GetCategoryName(),Tag,F ); else sprintf ( CIFErrorLocation,"structure %s.%s data [NULL]", Struct->GetCategoryName(),Tag ); return Error_NoData; } return 0; } int CIFGetReal ( realtype & R, PCMMCIFStruct Struct, cpstr Tag, Boolean Remove ) { int RC; pstr F; RC = Struct->GetReal ( R,Tag,Remove ); if (RC==CIFRC_WrongFormat) { F = Struct->GetString ( Tag,RC ); if (F) sprintf ( CIFErrorLocation,"structure %s.%s data %s", Struct->GetCategoryName(),Tag,F ); else sprintf ( CIFErrorLocation,"structure %s.%s data [NULL]", Struct->GetCategoryName(),Tag ); return Error_UnrecognizedReal; } if (RC) { F = Struct->GetString ( Tag,RC ); if (F) sprintf ( CIFErrorLocation,"structure %s.%s data %s", Struct->GetCategoryName(),Tag,F ); else sprintf ( CIFErrorLocation,"structure %s.%s data [NULL]", Struct->GetCategoryName(),Tag ); return Error_NoData; } return 0; } int CIFGetString ( pstr S, PCMMCIFStruct Struct, cpstr Tag, int SLen, cpstr DefS, Boolean Remove ) { int RC; pstr F; F = Struct->GetString ( Tag,RC ); if ((!RC) && F) { strcpy_n0 ( S,F,SLen-1 ); if (Remove) Struct->DeleteField ( Tag ); return 0; } else { strcpy ( S,DefS ); return 1; } } void PutIntIns ( pstr S, int N, int M, cpstr ins ) { // Integer N is converted into ASCII string of length M // and pasted onto first M characters of string S. No // terminating zero is added. The insert code ins is put // immediately after the integer. // If N is set to MinInt4, then first M+1 characters of // string S are set to space, and no insert code are // appended. int i; char L[50]; if (N==MinInt4) { for (i=0;i<=M;i++) S[i] = ' '; } else { if ((M!=4) || ((N>=-999) && (N<=9999))) sprintf ( L,"%*i",M,N ); else hy36encode ( M,N,L ); strcpy_n1 ( S,L,M ); if (ins[0]) S[M] = ins[0]; } } void Mat4Inverse ( mat44 & A, mat44 & AI ) { // *** FORMER RBRINV(A,AI) *** // Function to invert 4*4 matrices (AI=A^{-1}) mat44 c; mat33 x; realtype s,s1; int ii,jj,i,i1,j,j1; // ---- Get cofactors of 'a' in array 'c' s1 = 1.0; for (ii=0;ii<4;ii++) { s = s1; for (jj=0;jj<4;jj++) { i = -1; for (i1=0;i1<4;i1++) if (i1!=ii) { i++; j = -1; for (j1=0;j1<4;j1++) if (j1!=jj) { j++; x[i][j] = A[i1][j1]; } } c[ii][jj] = s*(x[0][0]*(x[1][1]*x[2][2]-x[1][2]*x[2][1]) + x[0][1]*(x[1][2]*x[2][0]-x[1][0]*x[2][2]) + x[0][2]*(x[1][0]*x[2][1]-x[1][1]*x[2][0])); s = -s; } s1 = -s1; } // ---- Calculate determinant s = 0.0; for (i=0;i<4;i++) s += A[i][0]*c[i][0]; // ---- Get inverse matrix if (s!=0.0) for (i=0;i<4;i++) for (j=0;j<4;j++) AI[i][j] = c[j][i]/s; } realtype Mat3Inverse ( mat33 & A, mat33 & AI ) { mat33 c,x; realtype s; int ii,jj,i,i1,j,j1; // Get cofactors of 'a' in array 'c' s = 1.0; for (ii=0;ii<3;ii++) for (jj=0;jj<3;jj++) { i = -1; for (i1=0;i1<3;i1++) if (i1!=ii) { i++; j = -1; for (j1=0;j1<3;j1++) if (j1!=jj) { j++; x[i][j] = A[i1][j1]; } } c[ii][jj] = s*(x[0][0]*x[1][1]-x[0][1]*x[1][0]); s = -s; } // Calculate determinant s = 0.0; for (i=0;i<3;i++) s += A[i][0]*c[i][0]; // Get inverse matrix if (s!=0.0) for (i=0;i<3;i++) for (j=0;j<3;j++) AI[i][j] = c[j][i]/s; return s; } void Mat4Mult ( mat44 & A, mat44 & B, mat44 & C ) { // Calculates A=B*C int i,j,k; for (i=0;i<4;i++) for (j=0;j<4;j++) { A[i][j] = 0.0; for (k=0;k<4;k++) A[i][j] += B[i][k]*C[k][j]; } } void Mat4Div1 ( mat44 & A, mat44 & B, mat44 & C ) { // Calculates A=B^{-1}*C mat44 B1; int i,j,k; B1[0][0] = 1.0; // in order to supress warnings from some // stupid compilers Mat4Inverse ( B,B1 ); for (i=0;i<4;i++) for (j=0;j<4;j++) { A[i][j] = 0.0; for (k=0;k<4;k++) A[i][j] += B1[i][k]*C[k][j]; } } void Mat4Div2 ( mat44 & A, mat44 & B, mat44 & C ) { // Calculates A=B*C^{-1} mat44 C1; int i,j,k; C1[0][0] = 1.0; // in order to supress warnings from some // stupid compilers Mat4Inverse ( C,C1 ); for (i=0;i<4;i++) for (j=0;j<4;j++) { A[i][j] = 0.0; for (k=0;k<4;k++) A[i][j] += B[i][k]*C1[k][j]; } } void Mat4Init ( mat44 & A ) { int i,j; for (i=0;i<4;i++) { for (j=0;j<4;j++) A[i][j] = 0.0; A[i][i] = 1.0; } } realtype Mat4RotDet ( mat44 & T ) { // returns determinant of the rotation part return T[0][0]*T[1][1]*T[2][2] + T[0][1]*T[1][2]*T[2][0] + T[1][0]*T[2][1]*T[0][2] - T[0][2]*T[1][1]*T[2][0] - T[0][0]*T[1][2]*T[2][1] - T[2][2]*T[0][1]*T[1][0]; } Boolean isMat4Unit ( mat44 & A, realtype eps, Boolean rotOnly ) { // returns True if A is a unit 4x4 matrix int i,j,k; Boolean B; if (rotOnly) k = 3; else k = 4; B = True; for (i=0;(iContinuationNo>1); } // =================== CContString ===================== CContString::CContString() : CContainerClass() { InitString(); } CContString::CContString ( cpstr S ) : CContainerClass() { InitString(); ConvertPDBASCII ( S ); } CContString::CContString ( RPCStream Object ) : CContainerClass(Object) { InitString(); } CContString::~CContString() { if (Line) delete[] Line; if (CIFCategory) delete[] CIFCategory; if (CIFTag) delete[] CIFTag; } void CContString::InitString() { Line = NULL; CIFCategory = NULL; CIFTag = NULL; } int CContString::ConvertPDBASCII ( cpstr S ) { CreateCopy ( Line,S ); return 0; } void CContString::PDBASCIIDump ( pstr S, int ) { if (Line) strcpy ( S,Line ); else strcpy ( S,"" ); } Boolean CContString::PDBASCIIDump1 ( RCFile f ) { if (Line) f.WriteLine ( Line ); else f.LF(); return True; } void CContString::GetCIF ( PCMMCIFData CIF, int & Signal ) { pstr F; int i,RC; char c; if ((!CIFCategory) || (!CIFTag)) { Signal = -1; return; } F = CIF->GetString ( CIFCategory,CIFTag,RC ); if (RC || (!F)) { Signal = -1; return; } if (Signal>=(int)strlen(F)) { CIF->DeleteField ( CIFCategory,CIFTag ); Signal = -1; return; } i = Signal; while (F[i] && (F[i]!='\n') && (F[i]!='\r')) i++; if ((Signal==0) && (i==0)) { i++; if (((F[Signal]=='\n') && (F[i]=='\r')) || ((F[Signal]=='\r') && (F[i]=='\n'))) i++; Signal = i; while (F[i] && (F[i]!='\n') && (F[i]!='\r')) i++; } c = F[i]; F[i] = char(0); CreateCopy ( Line,&(F[Signal]) ); if (c) { F[i] = c; Signal = i+1; if (((c=='\n') && (F[Signal]=='\r')) || ((c=='\r') && (F[Signal]=='\n'))) Signal++; } else CIF->DeleteField ( CIFCategory,CIFTag ); } void CContString::MakeCIF ( PCMMCIFData CIF, int N ) { pstr S; if ((!CIFCategory) || (!CIFTag)) return; S = new char[strlen(Line)+5]; strcpy ( S,"\n" ); strcat ( S,Line ); CIF->PutString ( S,CIFCategory,CIFTag,(N!=0) ); delete[] S; } Boolean CContString::Append ( PCContainerClass CC ) { if (CContainerClass::Append(CC)) { if (!Line) { Line = PCContString(CC)->Line; PCContString(CC)->Line = NULL; } else CreateConcat ( Line,pstr("\n"),PCContString(CC)->Line ); return True; } return False; } void CContString::Copy ( PCContainerClass CString ) { CreateCopy ( Line,PCContString(CString)->Line ); } void CContString::write ( RCFile f ) { byte Version=1; f.WriteByte ( &Version ); f.CreateWrite ( Line ); f.CreateWrite ( CIFCategory ); f.CreateWrite ( CIFTag ); } void CContString::read ( RCFile f ) { byte Version; f.ReadByte ( &Version ); f.CreateRead ( Line ); f.CreateRead ( CIFCategory ); f.CreateRead ( CIFTag ); } MakeStreamFunctions(CContString) // ============== CClassContainer ==================== MakeStreamFunctions(CContainerClass) CClassContainer::CClassContainer() : CStream() { Init(); } CClassContainer::CClassContainer ( RPCStream Object ) : CStream(Object) { Init(); } void CClassContainer::Init() { length = 0; Container = NULL; } CClassContainer::~CClassContainer() { FreeContainer(); } void CClassContainer::FreeContainer() { int i; if (Container) { for (i=0;i0) { i = length-1; while (i>=0) { if (!Container[i]) i--; else if (Container[i]->GetClassID()!=Data->GetClassID()) i--; else break; } if (i>=0) { if (Container[i]->Append(Data)) { delete Data; return; } } } C1 = new PCContainerClass[length+1]; for (i=0;iPDBASCIIDump1(f)) { Container[i]->PDBASCIIDump ( S,i ); j = strlen(S); while (j<80) S[j++] = ' '; S[80] = char(0); f.WriteLine ( S ); } } } int CClassContainer::GetCIF ( PCMMCIFData CIF, int ClassID ) { PCContainerClass ContainerClass; int Signal; Signal = 0; do { ContainerClass = MakeContainerClass ( ClassID ); ContainerClass->GetCIF ( CIF,Signal ); if (Signal>=0) AddData ( ContainerClass ); } while (Signal>=0); delete ContainerClass; return -(Signal+1); } void CClassContainer::MakeCIF ( PCMMCIFData CIF ) { int i; for (i=0;iMakeCIF ( CIF,i ); } void CClassContainer::write ( RCFile f ) { int i,ClassID; byte Version=1; f.WriteByte ( &Version ); f.WriteInt ( &length ); for (i=0;iGetClassID(); f.WriteInt ( &ClassID ); Container[i]->write ( f ); } else { ClassID = -1; f.WriteInt ( &ClassID ); } } PCContainerClass CClassContainer::MakeContainerClass ( int ClassID ) { if (ClassID==ClassID_String) return new CContString(); return new CContainerClass(); } PCContainerClass CClassContainer::GetContainerClass (int ContClassNo) { if ((ContClassNo<0) || (ContClassNo>=length)) return NULL; return Container[ContClassNo]; } void CClassContainer::Copy ( PCClassContainer CContainer ) { int i; FreeContainer(); if (CContainer) { length = CContainer->length; if (length>0) { Container = new PCContainerClass[length]; for (i=0;iContainer[i]) { Container[i] = MakeContainerClass ( CContainer->Container[i]->GetClassID() ); Container[i]->Copy ( CContainer->Container[i] ); } else Container[i] = NULL; } } } void CClassContainer::read ( RCFile f ) { int i,ClassID; byte Version; FreeContainer(); f.ReadByte ( &Version ); f.ReadInt ( &length ); if (length>0) { Container = new PCContainerClass[length]; for (i=0;i=0) { Container[i] = MakeContainerClass ( ClassID ); Container[i]->read ( f ); } else Container[i] = NULL; } } } MakeStreamFunctions(CClassContainer) // ====================== ID parsers ========================== CAtomPath::CAtomPath() : CStream() { InitAtomPath(); } CAtomPath::CAtomPath ( cpstr ID ) : CStream() { InitAtomPath(); SetPath ( ID ); } CAtomPath::CAtomPath ( RPCStream Object ) : CStream(Object) { InitAtomPath(); } CAtomPath::~CAtomPath() {} void CAtomPath::InitAtomPath() { modelNo = 0; chainID [0] = char(0); seqNum = MinInt4; insCode [0] = char(0); resName [0] = char(0); atomName[0] = char(0); element [0] = char(0); altLoc [0] = char(0); isSet = 0; } int CAtomPath::SetPath ( cpstr ID ) { // 1. If ID starts with '/': // /mdl/chn/seq(res).i/atm[elm]:a // // 2. If ID starts with a letter: // chn/seq(res).i/atm[elm]:a // // 3. If ID starts with a number: // seq(res).i/atm[elm]:a // // 4. If ID contains colon ':' then // it may be just // atm[elm]:a // // All spaces are ignored. isSet // sets bit for each element present. // Any element may be a wildcard '*'. // Wildcard for model will set modelNo=0, // for sequence number will set // seqNum=MinInt4. // // Returns: // 0 <-> Ok // -1 <-> wrong numerical format for model // -2 <-> wrong numerical format for sequence number // char N[100]; pstr p,p1; int i,k; isSet = 0; // clear all bits. p = pstr(ID); while (*p==' ') p++; if (!(*p)) return 0; if (*p=='/') { // model number p++; i = 0; while ((*p) && (*p!='/')) { if (*p!=' ') N[i++] = *p; p++; } N[i] = char(0); if ((!N[0]) || (N[0]=='*')) modelNo = 0; else { modelNo = mround(strtod(N,&p1)); if ((modelNo==0) && (p1==N)) return -1; } isSet |= APATH_ModelNo; if (*p!='/') return 0; p++; while (*p==' ') p++; } if ((*p<'0') || (*p>'9')) { // chain ID i = 0; k = sizeof(ChainID)-1; while ((*p) && (*p!='/')) { if ((*p!=' ') && (i='0') && (*p<='9')) || (*p=='-') || (*p=='(') || (*p=='.')) { // sequence number, residue name and insertion code i = 0; while ((*p) && (*p!='/')) { if (*p!=' ') N[i++] = *p; p++; } N[i] = char(0); i = ParseResID ( N,seqNum,insCode,resName ); if (i==2) return -2; isSet |= APATH_SeqNum | APATH_InsCode | APATH_ResName; if (*p!='/') return 0; p++; while (*p==' ') p++; } if (strchr(p,':') || strchr(p,'[')) { // atom name, chemical element and alternative location i = 0; while (*p) { if (*p!=' ') N[i++] = *p; p++; } N[i] = char(0); ParseAtomID ( N,atomName,element,altLoc ); isSet |= APATH_AtomName | APATH_Element | APATH_AltLoc; } return 0; } void CAtomPath::write ( RCFile f ) { byte Version=1; f.WriteByte ( &Version ); CStream::write ( f ); f.WriteInt ( &modelNo ); f.WriteInt ( &seqNum ); f.WriteInt ( &isSet ); f.WriteTerLine ( chainID ,False ); f.WriteTerLine ( insCode ,False ); f.WriteTerLine ( resName ,False ); f.WriteTerLine ( atomName,False ); f.WriteTerLine ( element ,False ); f.WriteTerLine ( altLoc ,False ); } void CAtomPath::read ( RCFile f ) { byte Version; f.ReadByte ( &Version ); CStream::read ( f ); f.ReadInt ( &modelNo ); f.ReadInt ( &seqNum ); f.ReadInt ( &isSet ); f.ReadTerLine ( chainID ,False ); f.ReadTerLine ( insCode ,False ); f.ReadTerLine ( resName ,False ); f.ReadTerLine ( atomName,False ); f.ReadTerLine ( element ,False ); f.ReadTerLine ( altLoc ,False ); } MakeStreamFunctions(CAtomPath) // -------------------------------------------------------- CQuickSort::CQuickSort() : CStream() { selSortLimit = 15; data = NULL; dlen = 0; } CQuickSort::CQuickSort ( RPCStream Object ) : CStream(Object) { selSortLimit = 15; data = NULL; dlen = 0; } int CQuickSort::Compare ( int i, int j ) { // sort by increasing data[i] if (((ivector)data)[i]<((ivector)data)[j]) return -1; if (((ivector)data)[i]>((ivector)data)[j]) return 1; return 0; } void CQuickSort::Swap ( int i, int j ) { int b; b = ((ivector)data)[i]; ((ivector)data)[i] = ((ivector)data)[j]; ((ivector)data)[j] = b; } void CQuickSort::SelectionSort ( int left, int right ) { int i,j,imin; for (i=left;i0) && (Compare(rm,lv)>0)); do lm++; while ((lm=l) i = l-1; wrd[i] = char(0); p = p1; } void ParseAtomID ( cpstr ID, AtomName aname, Element elname, AltLoc aloc ) { pstr p; p = pstr(ID); while (*p==' ') p++; strcpy ( aname ,"*" ); strcpy ( elname,"*" ); if (*p) aloc[0] = char(0); else strcpy ( aloc,"*" ); takeWord ( p,aname,pstr("[: "),sizeof(AtomName) ); if (*p=='[') { p++; takeWord ( p,elname,pstr("]: "),sizeof(Element) ); if (*p==']') p++; } if (*p==':') { p++; takeWord ( p,aloc,pstr(" "),sizeof(AltLoc) ); } } int ParseResID ( cpstr ID, int & sn, InsCode inscode, ResName resname ) { int RC; pstr p,p1; char N[100]; RC = 0; p = pstr(ID); while (*p==' ') p++; sn = ANY_RES; strcpy ( inscode,"*" ); strcpy ( resname,"*" ); N[0] = char(0); takeWord ( p,N,pstr("(./ "),sizeof(N) ); if ((!N[0]) || (N[0]=='*')) { sn = ANY_RES; RC = 1; } if (!RC) { sn = mround(strtod(N,&p1)); if (p1==N) RC = 2; else inscode[0] = char(0); } if (*p=='(') { p++; takeWord ( p,resname,pstr(")./ "),sizeof(ResName) ); if (*p==')') p++; } if (*p=='.') { p++; takeWord ( p,inscode,pstr("/ "),sizeof(InsCode) ); } return RC; } int ParseAtomPath ( cpstr ID, int & mdl, ChainID chn, int & sn, InsCode ic, ResName res, AtomName atm, Element elm, AltLoc aloc, PCAtomPath DefPath ) { // /mdl/chn/seq(res).i/atm[elm]:a, may be partial char N[100]; pstr p,p1; int i,RC; Boolean wasRes; wasRes = False; RC = 0; p = pstr(ID); while (*p==' ') p++; mdl = 0; if (*p=='/') { p++; N[0] = char(0); takeWord ( p,N,pstr("/"),sizeof(N) ); if ((!N[0]) || (N[0]=='*')) mdl = 0; else { mdl = mround(strtod(N,&p1)); if ((mdl==0) && (p1==N)) return -1; } } else if (DefPath) { if (DefPath->isSet & APATH_ModelNo) mdl = DefPath->modelNo; } strcpy ( chn,"*" ); if (*p=='/') p++; if ((*p<'0') || (*p>'9')) { p1 = p; chn[0] = char(0); takeWord ( p,chn,pstr("/"),sizeof(ChainID) ); if (strpbrk(chn,"(.[:-")) { // this was not a chain ID! if (DefPath) { if (DefPath->isSet & APATH_ChainID) strcpy ( chn,DefPath->chainID ); } else strcpy ( chn,"*" ); p = p1; } } else if (DefPath) { if (DefPath->isSet & APATH_ChainID) strcpy ( chn,DefPath->chainID ); } if (*p=='/') p++; sn = ANY_RES; strcpy ( ic ,"*" ); strcpy ( res,"*" ); if (((*p>='0') && (*p<='9')) || (*p=='-') || (*p=='(') || (*p=='.')) { wasRes = True; N[0] = char(0); takeWord ( p,N,pstr("/"),sizeof(N) ); i = ParseResID ( N,sn,ic,res ); if (i==2) return -2; } else if (DefPath) { wasRes = (*p=='/'); if (DefPath->isSet & APATH_SeqNum) sn = DefPath->seqNum; if (DefPath->isSet & APATH_InsCode) strcpy ( ic,DefPath->insCode ); if (DefPath->isSet & APATH_ResName) strcpy ( res,DefPath->resName ); } if (*p=='/') p++; strcpy ( atm ,"*" ); strcpy ( elm ,"*" ); strcpy ( aloc,"*" ); if (wasRes || strchr(p,':') || strchr(p,'[')) { ParseAtomID ( p,atm,elm,aloc ); } else if (DefPath) { if (DefPath->isSet & APATH_AtomName) strcpy ( atm,DefPath->atomName ); if (DefPath->isSet & APATH_Element) strcpy ( elm,DefPath->element ); if (DefPath->isSet & APATH_ResName) strcpy ( aloc,DefPath->altLoc ); } if (mdl<=0) RC |= APATH_WC_ModelNo; if (chn[0]=='*') RC |= APATH_WC_ChainID; if (sn==ANY_RES) RC |= APATH_WC_SeqNum; if (ic[0]=='*') RC |= APATH_WC_InsCode; if (res[0]=='*') RC |= APATH_WC_ResName; if (atm[0]=='*') RC |= APATH_WC_AtomName; if (elm[0]=='*') RC |= APATH_WC_Element; if (aloc[0]=='*') RC |= APATH_WC_AltLoc; if (RC & (APATH_WC_ModelNo | APATH_WC_ChainID | APATH_WC_SeqNum | APATH_WC_InsCode | APATH_WC_AtomName | APATH_WC_AltLoc)) RC |= APATH_Incomplete; return RC; } int ParseSelectionPath ( cpstr CID, int & iModel, pstr Chains, int & sNum1, InsCode ic1, int & sNum2, InsCode ic2, pstr RNames, pstr ANames, pstr Elements, pstr altLocs ) { int l,j; pstr p,p1; pstr N; int seqNum [2]; InsCode insCode[2]; pstr ID; Boolean wasModel,wasChain,wasRes,haveNeg; l = IMax(10,strlen(CID))+1; ID = new char[l]; N = new char[l]; p = pstr(CID); p1 = ID; while (*p) { if (*p!=' ') { *p1 = *p; p1++; } p++; } *p1 = char(0); p = ID; iModel = 0; strcpy ( Chains,"*" ); seqNum[0] = ANY_RES; seqNum[1] = ANY_RES; strcpy ( insCode[0],"*" ); strcpy ( insCode[1],"*" ); strcpy ( RNames ,"*" ); strcpy ( ANames ,"*" ); strcpy ( Elements ,"*" ); strcpy ( altLocs ,"*" ); wasModel = False; wasChain = False; wasRes = False; if (*p=='/') { // CID starts with the slash -- take model number first p++; N[0] = char(0); takeWord ( p,N,pstr("/"),l ); if ((!N[0]) || (N[0]=='*')) iModel = 0; else { iModel = mround(strtod(N,&p1)); if ((iModel==0) && (p1==N)) return -1; } if (*p=='/') p++; wasModel = True; } if ((*p) && (wasModel || (*p<'0') || (*p>'9'))) { p1 = p; Chains[0] = char(0); takeWord ( p,Chains,pstr("/"),l ); if (strpbrk(Chains,"(.[:-")) { // this was not a chain ID! strcpy ( Chains,"*" ); p = p1; } else wasChain = True; if (*p=='/') p++; } if ((*p) && (wasChain || ((*p>='0') && (*p<='9')) || (*p=='-') || (*p=='(') || (*p=='.') || (*p=='*'))) { j = 0; do { // take the sequence number haveNeg = False; if (*p=='-') { haveNeg = True; p++; } N[0] = char(0); takeWord ( p,N,pstr("(.-/"),l ); if ((!N[0]) || (N[0]=='*')) seqNum[j] = ANY_RES; else { seqNum[j] = mround(strtod(N,&p1)); if (p1==N) return -2; if (haveNeg) seqNum[j] = - seqNum[j]; } // take the residue list if (*p=='(') { p++; takeWord ( p,RNames,pstr(").-/"),l ); if (*p==')') p++; } // take the insertion code if (seqNum[j]!=ANY_RES) insCode[j][0] = char(0); if (*p=='.') { p++; takeWord ( p,insCode[j],pstr("-/"),sizeof(InsCode) ); } if (*p=='-') { p++; j++; } else { if (j==0) { seqNum[1] = seqNum[0]; strcpy ( insCode[1],insCode[0] ); } j = 10; } } while (j<2); wasRes = True; } else wasRes = (*p=='/'); if (*p=='/') p++; if ((*p) && (wasRes || strchr(p,':') || strchr(p,'['))) { if (*p) altLocs[0] = char(0); takeWord ( p,ANames,pstr("[:"),l ); if (!ANames[0]) strcpy ( ANames,"*" ); if (*p=='[') { p++; takeWord ( p,Elements,pstr("]:"),l ); if (*p==']') p++; } if (*p==':') { p++; takeWord ( p,altLocs,pstr(" "),l ); } } /* printf ( " iModel = %i\n" " Chains = '%s'\n" " seqNum1 = %i\n" " insCode1 = '%s'\n" " seqNum2 = %i\n" " insCode2 = '%s'\n" " RNames = '%s'\n" " ANames = '%s'\n" " Elements = '%s'\n" " altLocs = '%s'\n", iModel,Chains,seqNum[0],insCode[0], seqNum[1],insCode[1],RNames,ANames, Elements,altLocs ); */ sNum1 = seqNum[0]; sNum2 = seqNum[1]; strcpy ( ic1,insCode[0] ); strcpy ( ic2,insCode[1] ); delete[] ID; delete[] N; return 0; } void MakeSelectionPath ( pstr CID, int iModel, cpstr Chains, int sNum1, const InsCode ic1, int sNum2, const InsCode ic2, cpstr RNames, cpstr ANames, cpstr Elements, cpstr altLocs ) { char S[100]; int k; if (iModel>0) { sprintf ( CID,"/%i",iModel ); k = 1; } else { CID[0] = char(0); k = 0; } if (Chains[0]!='*') { if (k>0) strcat ( CID,"/" ); strcat ( CID,Chains ); k = 2; } if ((sNum1!=-MaxInt4) || (ic1[0]!='*')) { if (k>0) { if (k<2) strcat ( CID,"/*" ); strcat ( CID,"/" ); } if (sNum1>-MaxInt4) sprintf ( S,"%i",sNum1 ); else strcpy ( S,"*" ); if (ic1[0]!='*') { strcat ( S,"." ); strcat ( S,ic1 ); } strcat ( CID,S ); if ((sNum2!=-MaxInt4) || (ic2[0]!='*')) { strcat ( CID,"-" ); if (sNum1>-MaxInt4) sprintf ( S,"%i",sNum2 ); else strcpy ( S,"*" ); if (ic2[0]!='*') { strcat ( S,"." ); strcat ( S,ic2 ); } strcat ( CID,S ); } k = 3; } if (RNames[0]!='*') { if (k<1) strcat ( CID,"(" ); else if (k<2) strcat ( CID,"*/*(" ); else if (k<3) strcat ( CID,"/*(" ); strcat ( CID,RNames ); strcat ( CID,")" ); k = 4; } if (ANames[0]!='*') { if (k<1) strcat ( CID,"/*/*/*/" ); // full path else if (k<2) strcat ( CID,"/*/*/" ); // /mdl + /*/*/ else if (k<3) strcat ( CID,"/*/" ); // /mdl/chn + /*/ else if (k<4) strcat ( CID,"/" ); // /mdl/chn/res + / strcat ( CID,ANames ); strcat ( CID,")" ); k = 5; } if (Elements[0]!='*') { if (k<1) strcat ( CID,"[" ); else if (k<2) strcat ( CID,"/*/*/*[" ); else if (k<3) strcat ( CID,"/*/*[" ); else if (k<4) strcat ( CID,"/*[" ); else if (k<5) strcat ( CID,"[" ); strcat ( CID,Elements ); strcat ( CID,"]" ); k = 6; } if (altLocs[0]!='*') { if (k<1) strcat ( CID,":" ); else if (k<2) strcat ( CID,"/*/*/*:" ); else if (k<3) strcat ( CID,"/*/*:" ); else if (k<4) strcat ( CID,"/*:" ); else if (k<6) strcat ( CID,":" ); strcat ( CID,altLocs ); } } mmdb-1.25.5/mmdb/mmdb_rwbrook.cpp0000775000175000017500000031036511736610510013570 00000000000000// $Id: mmdb_rwbrook.cpp,v 1.46 2012/01/26 17:52:20 ekr Exp $ // ================================================================= // // CCP4 Coordinate Library: support of coordinate-related // functionality in protein crystallography applications. // // Copyright (C) Eugene Krissinel 2000-2008. // // This library is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // // ================================================================= // // 29.01.10 <-- Date of Last Modification. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ----------------------------------------------------------------- // // **** Module : MMDB_RWBrook // ~~~~~~~~~ // **** Project : MacroMolecular Data Base (MMDB) // ~~~~~~~~~ // **** Classes : CChannel ( I/O unit class ) // ~~~~~~~~~ // **** Functions : mmdb_f_init_ ( initializer ) // ~~~~~~~~~~~ mmdb_f_quit_ ( disposer ) // autoserials_ ( switch to the autoserials regime ) // setreadcoords_ ( switch for reading coordinates ) // simrwbrook_ ( simulates old RWBROOK printout ) // mmdb_f_openl_ ( associates a unit with a file ) // mmdb_f_open_ ( associates a unit with a file ) // mmdb_f_copy_ ( copies contents of units ) // mmdb_f_delete_ ( deletes part of a unit ) // mmdb_f_settype_ ( changes type of file and r/w mode ) // mmdb_f_setname_ ( changes file name ) // mmdb_f_write_ ( writes a data structure into file ) // mmdb_f_close_ ( closes and disposes a data str-re ) // mmdb_f_advance_ ( advances the internal pointer ) // mmdb_f_rewd_ ( sets internal pointer on the top ) // mmdb_f_bksp_ ( shifts int-l pointer 1 atom back ) // mmdb_f_atom_ ( reads/writes atom properties ) // mmdb_f_coord_ ( reads/writes atom coordinates ) // mmdb_f_setcell_ ( sets the crystal cell parameters ) // mmdb_f_wbspgrp_ ( sets the space group ) // mmdb_f_rbspgrp_ ( gets the space group ) // mmdb_f_wbcell_ ( sets the crystal cell parameters ) // mmdb_f_rbcell_ ( gets the crystal cell parameters ) // mmdb_f_rbcelln_ ( gets the crystal cell parameters ) // mmdb_f_rbrcel_ ( gets the recipricol cell ) // mmdb_f_rborf_ ( returns or fill transf. matrices ) // mmdb_f_orthmat_ ( calc. standard othogonalisations ) // mmdb_f_cvanisou_ ( converts between cryst-c units ) // mmdb_f_wremark_ ( writes a remark statement ) // mmdb_f_setter // mmdb_f_sethet // rberrstop_ ( error messenger ) // rbcheckerr_ ( a simple error messenger ) // // (C) E. Krissinel 2000-2010 // // ================================================================= // // Note: what if the orthogonalization code is not defined? // #ifndef __STRING_H #include "string.h" #endif #ifndef __STDLIB_H #include "stdlib.h" #endif #ifndef __MATH_H #include "math.h" #endif #ifndef __MMDB_RWBrook__ #include "mmdb_rwbrook.h" #endif #ifndef __MMDB_Manager__ #include "mmdb_manager.h" #endif #ifndef __MMDB_Tables__ #include "mmdb_tables.h" #endif #include "hybrid_36.h" // ========================== CChannel =========================== DefineClass(CChannel) class CChannel { public : int nUnit; // unit number int nType; // unit type: 0- PDB; 1- CIF; 2- binary int nRead; // 0: input, 1: output PCMMDBManager MMDBManager; // MMDB manager pstr FName; // file name int fPos; // "position" in the file int ErrCode; // error code of last operation Boolean FAutoSer; // autoserials flag for reading PDB Boolean FReadCoords; // flag to read coordinate section Boolean FSimRWBROOK; // flag to simulate old RWBROOK's printout CChannel (); ~CChannel(); void Dispose(); void Init (); void SetFileType ( pstr FType ); void SetFileName ( pstr FileName, int FNameLen ); void IdentifyFile( pstr ExistingFName ); Boolean EndOfFile (); PCAtom * GetAtomArray(); PCAtom GetAtomI ( int index ); PCMMDBCryst GetCryst (); Boolean areCrystMatrices(); void Frac2Orth ( realtype x, realtype y, realtype z, realtype & xx, realtype & yy, realtype & zz ); void Orth2Frac ( realtype x, realtype y, realtype z, realtype & xx, realtype & yy, realtype & zz ); void Cryst2Orth ( rvector U ); void Orth2Cryst ( rvector U ); int SetCell ( realtype cell_a, realtype cell_b, realtype cell_c, realtype cell_alpha, realtype cell_beta, realtype cell_gamma, int OrthCode ); int PutCell ( realtype cell_a, realtype cell_b, realtype cell_c, realtype cell_alpha, realtype cell_beta, realtype cell_gamma, int OrthCode ); int SetSpGroup ( pstr spGroup ); int GetSpGroup ( pstr spGroup ); int GetCell ( realtype & cell_a, realtype & cell_b, realtype & cell_c, realtype & cell_alpha, realtype & cell_beta, realtype & cell_gamma, realtype & cell_v, int & OrthCode ); int GetRCell ( realtype & cell_as, realtype & cell_bs, realtype & cell_cs, realtype & cell_alphas, realtype & cell_betas, realtype & cell_gammas, realtype & cell_vs ); void MakeCoordStructure(); void Read (); void Write(); void GetInputBuffer ( pstr Line, int & count ); protected : void TranslateError(); }; CChannel::CChannel() { Init(); } CChannel::~CChannel() { Dispose(); } void CChannel::Init() { nUnit = -1; nType = -1; nRead = 0; MMDBManager = NULL; FName = NULL; ErrCode = 0; fPos = 0; FAutoSer = False; FReadCoords = True; FSimRWBROOK = False; } void CChannel::Dispose() { if (MMDBManager) delete MMDBManager; if (FName) delete[] FName; MMDBManager = NULL; FName = NULL; nUnit = -1; nType = -1; nRead = 0; ErrCode = 0; fPos = 0; } void CChannel::SetFileType ( pstr FType ) { switch (FType[0]) { default : case ' ' : if (nRead==0) nType = -1; // auto at reading else if (MMDBManager) nType = MMDBManager->FType; // auto at writing else nType = -1; break; case 'P' : nType = 0; break; // PDB case 'C' : nType = 1; break; // CIF case 'B' : nType = 2; break; // BIN } } void CChannel::IdentifyFile ( pstr ExistingFName ) { if (nType==-1) { if (ExistingFName) { if (isMMDBBIN(ExistingFName)==0) nType = 2; else if (isPDB(ExistingFName,GZM_CHECK,True)==0) nType = 0; else if (isCIF(ExistingFName)==0) nType = 1; else nType = -2; // unidentified } else { if (MMDBManager) { if (MMDBManager->FType<0) nType = 0; // PDB else nType = MMDBManager->FType; // same as it was on last input } else nType = 0; } } } void CChannel::SetFileName ( pstr FileName, int FNameLen ) { if (FName) delete[] FName; FName = new char[FNameLen+1]; strncpy ( FName,FileName,FNameLen ); FName[FNameLen] = char(0); } void CChannel::MakeCoordStructure() { if (MMDBManager) MMDBManager->Delete ( MMDBFCM_All ); else { MMDBManager = new CMMDBManager(); MMDBManager->SetFlag ( MMDBF_AllowDuplChainID ); } } void CChannel::Read() { int RC; ErrCode = -2; if (!FName) return; MakeCoordStructure(); IdentifyFile ( FName ); if (FAutoSer) MMDBManager->SetFlag ( MMDBF_AutoSerials ); else MMDBManager->RemoveFlag ( MMDBF_AutoSerials ); if (FReadCoords) MMDBManager->RemoveFlag ( MMDBF_NoCoordRead ); else MMDBManager->SetFlag ( MMDBF_NoCoordRead ); if (FSimRWBROOK) MMDBManager->SetFlag ( MMDBF_SimRWBROOK ); else MMDBManager->RemoveFlag ( MMDBF_SimRWBROOK ); MMDBManager->SetFlag ( MMDBF_IgnoreDuplSeqNum | MMDBF_IgnoreBlankLines | MMDBF_IgnoreRemarks | MMDBF_IgnoreNonCoorPDBErrors | MMDBF_AllowDuplChainID ); switch (nType) { default : nType = 0; // nType=-2: unidentified: try PDB case 0 : ErrCode = MMDBManager->ReadPDBASCII ( FName ); break; case 1 : ErrCode = MMDBManager->ReadCIFASCII ( FName ); break; case 2 : ErrCode = MMDBManager->ReadMMDBF ( FName ); break; } if (ErrCode==0) { RC = MMDBManager->CrystReady(); switch (RC) { case CRRDY_NoTransfMatrices : ErrCode = RWBERR_NoMatrices; break; case CRRDY_Unchecked : ErrCode = RWBERR_NoCheck; break; case CRRDY_Ambiguous : ErrCode = RWBERR_Disagreement; break; case CRRDY_NoCell : ErrCode = RWBERR_NoCellParams; break; default : ; } } fPos = 0; // begining of the file TranslateError(); } void CChannel::Write() { ErrCode = -3; if ((!MMDBManager) || (!FName)) return; IdentifyFile ( FName ); switch (nType) { default : nType = 0; // nType=-2: unidentified: make PDB case 0 : ErrCode = MMDBManager->WritePDBASCII ( FName ); break; case 1 : ErrCode = MMDBManager->WriteCIFASCII ( FName ); break; case 2 : ErrCode = MMDBManager->WriteMMDBF ( FName ); break; } // we do not change fPos here! TranslateError(); } void CChannel::TranslateError() { switch (ErrCode) { case Error_CantOpenFile : ErrCode = RWBERR_CantOpenFile; break; case Error_UnrecognizedInteger : ErrCode = RWBERR_WrongInteger; break; case Error_NoData : ErrCode = RWBERR_NotACIFFile; break; case Error_WrongModelNo : ErrCode = RWBERR_WrongModelNo; break; case Error_DuplicatedModel : ErrCode = RWBERR_DuplicatedModel; break; case Error_ForeignFile : ErrCode = RWBERR_ForeignFile; break; case Error_WrongEdition : ErrCode = RWBERR_WrongEdition; break; case Error_ATOM_Unrecognized : ErrCode = RWBERR_ATOM_Unrecognd; break; case Error_ATOM_AlreadySet : ErrCode = RWBERR_ATOM_AlreadySet; break; case Error_ATOM_NoResidue : ErrCode = RWBERR_ATOM_NoResidue; break; case Error_ATOM_Unmatch : ErrCode = RWBERR_ATOM_Unmatch; break; case Error_NotACIFFile : ErrCode = RWBERR_NotACIFFile; break; case Error_UnrecognCIFItems : ErrCode = RWBERR_UnrecognCIFItems; break; case Error_MissingCIFField : ErrCode = RWBERR_MissingCIFField; break; case Error_EmptyCIFLoop : ErrCode = RWBERR_EmptyCIFLoop; break; case Error_UnexpEndOfCIF : ErrCode = RWBERR_UnexpEndOfCIF; break; case Error_MissgCIFLoopField : ErrCode = RWBERR_MissgCIFLoopField; break; case Error_NotACIFStructure : ErrCode = RWBERR_NotACIFStructure; break; case Error_NotACIFLoop : ErrCode = RWBERR_NotACIFLoop; break; case Error_UnrecognizedReal : ErrCode = RWBERR_WrongReal; break; case Error_Ok : ErrCode = RWBERR_Ok; break; case Error_WrongChainID : ErrCode = RWBERR_WrongChainID; break; case Error_WrongEntryID : ErrCode = RWBERR_WrongEntryID; break; case Error_SEQRES_serNum : ErrCode = RWBERR_SEQRES_serNum; break; case Error_SEQRES_numRes : ErrCode = RWBERR_SEQRES_numRes; break; case Error_SEQRES_extraRes : ErrCode = RWBERR_SEQRES_exraRes; break; case Error_NCSM_Unrecognized : ErrCode = RWBERR_NCSM_Unrecogn; break; case Error_NCSM_AlreadySet : ErrCode = RWBERR_NCSM_AlreadySet; break; case Error_NCSM_WrongSerial : ErrCode = RWBERR_NCSM_WrongSerial; break; case Error_NCSM_UnmatchIG : ErrCode = RWBERR_NCSM_UnmatchIG; break; case Error_NoModel : ErrCode = RWBERR_NoModel; break; case Error_NoSheetID : ErrCode = RWBERR_NoSheetID; break; case Error_WrongSheetID : ErrCode = RWBERR_WrongSheetID; break; case Error_WrongStrandNo : ErrCode = RWBERR_WrongStrandNo; break; case Error_WrongNumberOfStrands : ErrCode = RWBERR_WrongNofStrands; break; case Error_WrongSheetOrder : ErrCode = RWBERR_WrongSheetOrder; break; case Error_HBondInconsistency : ErrCode = RWBERR_HBondInconsis; break; case Error_EmptyResidueName : ErrCode = RWBERR_EmptyResidueName; break; case Error_DuplicateSeqNum : ErrCode = RWBERR_DuplicateSeqNum; break; case Error_NoLogicalName : ErrCode = RWBERR_NoLogicalName; break; case Error_GeneralError1 : ErrCode = RWBERR_GeneralError1; break; default : ; } } Boolean CChannel::EndOfFile() { int nA; if (MMDBManager) { nA = MMDBManager->GetNumberOfAtoms(); if (fPos>nA) { fPos = nA+1; return True; } } else return True; return False; } PCAtom * CChannel::GetAtomArray() { if (MMDBManager) return MMDBManager->GetAtomArray(); else return NULL; } PCAtom CChannel::GetAtomI ( int index ) { // returns index-th atom, as counted from the // top of file if (MMDBManager) return MMDBManager->GetAtomI ( index ); else return NULL; } PCMMDBCryst CChannel::GetCryst() { if (MMDBManager) return &(MMDBManager->Cryst); else return NULL; } Boolean CChannel::areCrystMatrices() { if (MMDBManager) return MMDBManager->Cryst.areMatrices(); else return False; } void CChannel::Frac2Orth ( realtype x, realtype y, realtype z, realtype & xx, realtype & yy, realtype & zz ) { if (MMDBManager) MMDBManager->Cryst.Frac2Orth ( x,y,z,xx,yy,zz ); else { xx = x; yy = y; zz = z; } } void CChannel::Orth2Frac ( realtype x, realtype y, realtype z, realtype & xx, realtype & yy, realtype & zz ) { if (MMDBManager) MMDBManager->Cryst.Orth2Frac ( x,y,z,xx,yy,zz ); else { xx = x; yy = y; zz = z; } } void CChannel::Cryst2Orth ( rvector U ) { if (MMDBManager) MMDBManager->Cryst.Cryst2Orth ( U ); } void CChannel::Orth2Cryst ( rvector U ) { if (MMDBManager) MMDBManager->Cryst.Orth2Cryst ( U ); } int CChannel::PutCell ( realtype cell_a, realtype cell_b, realtype cell_c, realtype cell_alpha, realtype cell_beta, realtype cell_gamma, int OrthCode ) { if (MMDBManager) { MMDBManager->Cryst.PutCell ( cell_a,cell_b,cell_c, cell_alpha,cell_beta,cell_gamma, OrthCode ); if ((cell_a!=0.0) || (OrthCode>0)) { if (MMDBManager->Cryst.CellCheck & CCHK_Disagreement) return RWBERR_Disagreement; if (MMDBManager->Cryst.CellCheck & CCHK_NoOrthCode) return RWBERR_NoOrthCode; if (MMDBManager->Cryst.CellCheck & CCHK_Unchecked) return RWBERR_NoCheck; } return RWBERR_Ok; } else return RWBERR_NoFile; } int CChannel::SetCell ( realtype cell_a, realtype cell_b, realtype cell_c, realtype cell_alpha, realtype cell_beta, realtype cell_gamma, int OrthCode ) { if (MMDBManager) { MMDBManager->Cryst.SetCell ( cell_a,cell_b,cell_c, cell_alpha,cell_beta,cell_gamma, OrthCode ); if (MMDBManager->Cryst.CellCheck & CCHK_Disagreement) return RWBERR_Disagreement; if (MMDBManager->Cryst.CellCheck & CCHK_NoOrthCode) return RWBERR_NoOrthCode; if (MMDBManager->Cryst.CellCheck & CCHK_Unchecked) return RWBERR_NoCheck; return RWBERR_Ok; } else return RWBERR_NoFile; } int CChannel::SetSpGroup ( pstr spGroup ) { if (MMDBManager) { MMDBManager->SetSpaceGroup(spGroup); return RWBERR_Ok; } else return RWBERR_NoFile; } int CChannel::GetSpGroup ( pstr spGroup ) { if (MMDBManager) { if (MMDBManager->Cryst.WhatIsSet & CSET_SpaceGroup) strcpy ( spGroup,MMDBManager->Cryst.spaceGroup ); else strcpy ( spGroup," " ); return RWBERR_Ok; } else return RWBERR_NoFile; } int CChannel::GetCell ( realtype & cell_a, realtype & cell_b, realtype & cell_c, realtype & cell_alpha, realtype & cell_beta, realtype & cell_gamma, realtype & cell_v, int & OrthCode ) { if (MMDBManager) { cell_a = MMDBManager->Cryst.a; cell_b = MMDBManager->Cryst.b; cell_c = MMDBManager->Cryst.c; cell_alpha = MMDBManager->Cryst.alpha; cell_beta = MMDBManager->Cryst.beta; cell_gamma = MMDBManager->Cryst.gamma; cell_v = MMDBManager->Cryst.Vol; OrthCode = MMDBManager->Cryst.NCode; if (!(MMDBManager->Cryst.WhatIsSet & CSET_CellParams)) return RWBERR_NoCellParams; if (!(MMDBManager->Cryst.WhatIsSet & CSET_Transforms)) return RWBERR_NoCheck; // if (MMDBManager->Cryst.CellCheck & CCHK_NoOrthCode) // return RWBERR_NoOrthCode; return RWBERR_Ok; } else return RWBERR_NoFile; } int CChannel::GetRCell ( realtype & cell_as, realtype & cell_bs, realtype & cell_cs, realtype & cell_alphas, realtype & cell_betas, realtype & cell_gammas, realtype & cell_vs ) { if (MMDBManager) { MMDBManager->Cryst.GetRCell ( cell_as,cell_bs,cell_cs, cell_alphas,cell_betas,cell_gammas, cell_vs ); if (!(MMDBManager->Cryst.WhatIsSet & CSET_CellParams)) return RWBERR_NoCellParams; if (!(MMDBManager->Cryst.WhatIsSet & CSET_Transforms)) return RWBERR_NoCheck; return RWBERR_Ok; } else return RWBERR_NoFile; } void CChannel::GetInputBuffer ( pstr Line, int & count ) { if (MMDBManager) MMDBManager->GetInputBuffer ( Line,count ); else { strcpy ( Line,"" ); count = -1; } } // ======================== static data =========================== static int nChannels; // number of channels in processing static PCChannel * Channel; // array of channels in processing static Boolean FAutoSer; // flag to automatically generate // serial numbers at reading PDB files static Boolean FReadCoords; // flag to read coordinates; if set to // False, only the header of PDB file // is read static Boolean FSimRWBROOK; // flag to simulate old RWBROOK printout // as closely as possible static char LastFunc[80]; // name of the last called function static int LastUnit; // number of the last unit called static int LastRC; // last return code static int LastSer; // last serial number kept for // certain warnings // ======================== RWBrook API =========================== FORTRAN_SUBR ( MMDB_F_INIT, mmdb_f_init,(),(),() ) { InitMatType(); nChannels = 0; Channel = NULL; strcpy ( LastFunc,"MMDB_F_Init" ); LastUnit = -1; LastRC = 0; LastSer = 0; FAutoSer = False; FReadCoords = True; FSimRWBROOK = False; } FORTRAN_SUBR ( MMDB_F_QUIT, mmdb_f_quit,(),(),() ) { int i; for (i=0;inUnit==iUnit) return i; } return -1; } int MakeChannel ( int iUnit ) { // If iUnit-th unit already exists, it is // reinitialized. Otherwise the function looks // for a not used channel, and if there is one, // associates the new iUnit-th unit with it. // If there is no unused channels, the new one // is created and the new iUnit-th unit is // associated with it. // Returns serial number of the channel // associated with the newly reinitialized // or created unit. int i,m; PCChannel * Channel1; m = GetChannel ( iUnit ); if (m>=0) { // such channel already exists Channel[m]->Dispose(); // clear it first Channel[m]->Init(); // reinitialize it Channel[m]->nUnit = iUnit; return m; } for (i=0;inUnit = iUnit; return m; } FORTRAN_SUBR ( MMDB_F_OPEN, mmdb_f_open, ( // lengths-at-end list fpstr FName, // file name fpstr RWStat, // "INPUT" or "OUTPUT" fpstr FType, // "PDB", "CIF", "BIN" or " " int * iUnit, // channel number int * iRet, // returns error code int FName_len, // fortran-hidden length of FName int RWStat_len, // fortran-hidden length of RWStat int FType_len // fortran-hidden length of FType ), ( // lengths-in-structure list fpstr FName, fpstr RWStat, fpstr FType, int * iUnit, int * iRet ), ( // lengths-follow list fpstr FName, int FName_len, fpstr RWStat, int RWStat_len, fpstr FType, int FType_len, int * iUnit, int * iRet ) ) { UNUSED_ARGUMENT(RWStat_len); UNUSED_ARGUMENT(FType_len); int k; char L[500]; #ifdef WIN32 GetStrTerWin32File ( L,FTN_STR(FName),0,sizeof(L),FTN_LEN(FName) ); #else GetStrTer ( L,FTN_STR(FName),0,sizeof(L),FTN_LEN(FName) ); #endif strcpy ( LastFunc,"MMDB_F_Open" ); LastUnit = *iUnit; if (*iUnit==0) { // generate unit number *iUnit = 1; do { k = GetChannel ( *iUnit ); if (k>=0) *iUnit = *iUnit+1; } while (k>=0); } // create channel k = MakeChannel ( *iUnit ); if (k>=0) { if (FTN_STR(RWStat)[0]=='I') { Channel[k]->nRead = 0; Channel[k]->FAutoSer = FAutoSer; Channel[k]->FReadCoords = FReadCoords; Channel[k]->FSimRWBROOK = FSimRWBROOK; } else Channel[k]->nRead = 1; // store file name Channel[k]->SetFileName ( L,sizeof(L) ); // store unit type Channel[k]->SetFileType ( FTN_STR(FType) ); Channel[k]->IdentifyFile( L ); if (FSimRWBROOK) { switch (Channel[k]->nType) { default : printf ( " unknown-format" ); break; case 0 : printf ( " PDB" ); break; case 1 : printf ( " mmCIF" ); break; case 2 : printf ( " MMDB BINARY" ); } printf ( " file is being opened on unit %i",*iUnit ); if (FTN_STR(RWStat)[0]=='I') printf ( " for INPUT.\n\n" ); else printf ( " for OUTPUT.\n\n" ); } if (FTN_STR(RWStat)[0]=='I') { Channel[k]->Read(); *iRet = Channel[k]->ErrCode; } else { Channel[k]->MakeCoordStructure(); Channel[k]->fPos = 1; *iRet = RWBERR_Ok; } } else *iRet = RWBERR_NoChannel; LastRC = *iRet; } FORTRAN_SUBR ( MMDB_F_OPENL, mmdb_f_openl, ( // lengths-at-end list fpstr LName, // logical name fpstr RWStat, // "INPUT" or "OUTPUT" fpstr FType, // "PDB", "CIF", "BIN" or " " int * iUnit, // channel number int * iRet, // returns error code int LName_len, // fortran-hidden length of LName int RWStat_len, // fortran-hidden length of RWStat int FType_len // fortran-hidden length of FType ), ( // lengths-in-structure list fpstr LName, fpstr RWStat, fpstr FType, int * iUnit, int * iRet ), ( // lengths-follow list fpstr LName, int LName_len, fpstr RWStat, int RWStat_len, fpstr FType, int FType_len, int * iUnit, int * iRet ) ) { char L[200]; pstr S; char_struct(FName) strcpy ( LastFunc,"MMDB_F_Openl" ); GetStrTer ( L,FTN_STR(LName),0,sizeof(L),FTN_LEN(LName) ); S = getenv ( L ); if (S) { fill_char_struct(FName,S) } else if (FTN_STR(RWStat)[0]=='O') { // The user may not have assigned a logical // for output, so that the program should write file "XYZOUT". This // is allowed as a convenience when user is not really interested // in output file. fill_char_struct(FName,L) } else { *iRet = RWBERR_NoLogicalName; return; } printf ( "\n Logical name: %s File name: %s\n",L,FName ); FORTRAN_CALL ( MMDB_F_OPEN, mmdb_f_open, ( FName,RWStat,FType,iUnit,iRet, FName_len,RWStat_len,FType_len ), ( &FName,RWStat,FType,iUnit,iRet ), ( FName,FName_len,RWStat,RWStat_len, FType,FType_len,iUnit,iRet ) ); } FORTRAN_SUBR ( MMDB_F_COPY, mmdb_f_copy, ( // lengths-at-end list int * iUnit1, // destination unit int * iUnit2, // source unit int * copyKey, // copy key: // = 1 copy all // = 2 copy all except coordinates // = 3 copy title section only // = 4 copy crystallographic // section only // = 5 copy coordinate section only // any other value does not do anything int * iRet // return code: // =0 if success // =RWBERR_NoChannel if a unit // does not exist ), ( // lengths-in-structure list int * iUnit1, int * iUnit2, int * copyKey, int * iRet ), ( // lengths-follow list int * iUnit1, int * iUnit2, int * copyKey, int * iRet ) ) { int k1,k2; word copyMask; strcpy ( LastFunc,"MMDB_F_Copy" ); LastUnit = *iUnit1; k1 = GetChannel ( LastUnit ); if (k1>=0) { if (Channel[k1]->MMDBManager) { LastUnit = *iUnit2; k2 = GetChannel ( LastUnit ); if (k2>=0) { if (Channel[k2]->MMDBManager) { switch (*copyKey) { case 1 : copyMask = MMDBFCM_All; break; case 2 : copyMask = MMDBFCM_Top; break; case 3 : copyMask = MMDBFCM_Title; break; case 4 : copyMask = MMDBFCM_Cryst; break; case 5 : copyMask = MMDBFCM_Coord; break; default : copyMask = 0x0000; } Channel[k1]->MMDBManager->Copy ( Channel[k2]->MMDBManager, copyMask ); *iRet = RWBERR_Ok; } else *iRet = RWBERR_NoFile; } else *iRet = RWBERR_NoChannel; } else *iRet = RWBERR_NoFile; } else *iRet = RWBERR_NoChannel; LastRC = *iRet; } FORTRAN_SUBR ( MMDB_F_DELETE, mmdb_f_delete, ( // lengths-at-end list int * iUnit, // unit number; *iUnit<=0 means // "the last mentioned unit" int * delKey, // delete key: // = 1 delete all // = 2 delete all except coordinates // = 3 delete title section only // = 4 delete crystallographic // section only // = 5 delete coordinate section only // any other value does not do anything int * iRet // return code: // =0 if success // =RWBERR_NoChannel if a unit // does not exist // =RWBERR_NoFile if a unit // was not opened ), ( // lengths-in-structure list int * iUnit, int * delKey, int * iRet ), ( // lengths-follow list int * iUnit, int * delKey, int * iRet ) ) { int k; word delMask; strcpy ( LastFunc,"MMDB_F_Delete" ); if (*iUnit>0) LastUnit = *iUnit; k = GetChannel ( LastUnit ); if (k>=0) { if (Channel[k]->MMDBManager) { switch (*delKey) { case 1 : delMask = MMDBFCM_All; break; case 2 : delMask = MMDBFCM_Top; break; case 3 : delMask = MMDBFCM_Title; break; case 4 : delMask = MMDBFCM_Cryst; break; case 5 : delMask = MMDBFCM_Coord; break; default : delMask = 0x0000; } Channel[k]->MMDBManager->Delete ( delMask ); *iRet = RWBERR_Ok; } else *iRet = RWBERR_NoFile; } else *iRet = RWBERR_NoChannel; LastRC = *iRet; } FORTRAN_SUBR ( MMDB_F_SETTYPE, mmdb_f_settype, ( // lengths-at-end list int * iUnit, // unit number fpstr FType, // "PDB", "CIF", "BIN" or " " fpstr RWStat, // "INPUT" or "OUTPUT" int * iRet, // returns -1 if unit not found, // otherwise 0 int FType_len, // fortran-hidden length of FType int RWStat_len // fortran-hidden length of RWStat ), ( // lengths-in-structure list int * iUnit, fpstr FType, fpstr RWStat, int * iRet ), ( // length-follow list int * iUnit, fpstr FType, int FType_len, fpstr RWStat, int RWStat_len, int * iRet ) ) { UNUSED_ARGUMENT(FType_len); UNUSED_ARGUMENT(RWStat_len); int k; strcpy ( LastFunc,"MMDB_F_SetType" ); if (*iUnit>0) LastUnit = *iUnit; k = GetChannel ( LastUnit ); if (k>=0) { // store unit type Channel[k]->SetFileType ( FTN_STR(FType) ); // store unit mode if (FTN_STR(RWStat)[0]=='I') Channel[k]->nRead = 0; else Channel[k]->nRead = 1; *iRet = RWBERR_Ok; } else *iRet = RWBERR_NoChannel; LastRC = *iRet; } FORTRAN_SUBR ( MMDB_F_SETNAME, mmdb_f_setname, ( // lengths-at-end list int * iUnit, // unit number fpstr FName, // file name int * iRet, // returns -1 if unit not found, // otherwise 0 int FName_len // fortran-hidden length of FName ), ( // lengths-in-structure list int * iUnit, fpstr FName, int * iRet ), ( // lengths-follow list int * iUnit, fpstr FName, int FName_len, int * iRet ) ) { int k; strcpy ( LastFunc,"MMDB_F_SetName" ); if (*iUnit>0) LastUnit = *iUnit; k = GetChannel ( LastUnit ); if (k<0) *iRet = RWBERR_NoChannel; else { // store file name Channel[k]->SetFileName ( FTN_STR(FName),FTN_LEN(FName) ); *iRet = RWBERR_Ok; } LastRC = *iRet; } FORTRAN_SUBR ( MMDB_F_WRITE, mmdb_f_write, ( int * iUnit, int * iRet ), ( int * iUnit, int * iRet ), ( int * iUnit, int * iRet ) ) { int k; strcpy ( LastFunc,"MMDB_F_Write" ); if (*iUnit>0) LastUnit = *iUnit; k = GetChannel ( LastUnit ); if (k<0) *iRet = RWBERR_NoChannel; else { Channel[k]->Write(); *iRet = Channel[k]->ErrCode; } LastRC = *iRet; } FORTRAN_SUBR ( MMDB_F_CLOSE, mmdb_f_close, ( int * iUnit, int * iRet ), ( int * iUnit, int * iRet ), ( int * iUnit, int * iRet ) ) { int k; strcpy ( LastFunc,"MMDB_F_Close" ); if (*iUnit>0) LastUnit = *iUnit; k = GetChannel ( LastUnit ); if (k<0) *iRet = RWBERR_NoChannel; else if (Channel[k]->nRead==1) { Channel[k]->Write(); *iRet = Channel[k]->ErrCode; if (!(*iRet)) { delete Channel[k]; Channel[k] = NULL; } } else { delete Channel[k]; Channel[k] = NULL; *iRet = RWBERR_Ok; } LastRC = *iRet; } FORTRAN_SUBR ( MMDB_F_ADVANCE, mmdb_f_advance, ( // lengths-at-end list int * iUnit, // unit number int * iOut, // output echo file int * iTer, // FLAG =1, return iRet=1 if 'ter' card found // =0, do not return on 'ter' card int * iRet // =0 if normal return // =1 if return on 'ter' card (iTer=1) // =2 if return on end of file // =3 if return on 'hetatm' card // =RWBERR_NoChannel if unit does not exist // =RWBERR_NoAdvance if pointer was not // advanced ), ( // lengths-in-structure list int * iUnit, int * iOut, int * iTer, int * iRet ), ( // lengths-follow list int * iUnit, int * iOut, int * iTer, int * iRet ) ) { UNUSED_ARGUMENT(iOut); int k; PCAtom atom; strcpy ( LastFunc,"mmdb_f_advance" ); LastUnit = *iUnit; k = GetChannel ( *iUnit ); if (k<0) *iRet = RWBERR_NoChannel; else if (Channel[k]->nRead==0) { // in the input file, try to get pointer on the next atom do { Channel[k]->fPos++; // advance the pointer on Atom array if (Channel[k]->EndOfFile()) { atom = NULL; break; } atom = Channel[k]->GetAtomI ( Channel[k]->fPos ); if (atom) { if ((atom->Ter) && (*iTer==0)) { // ignore 'ter' card if iTer is set to 0 atom = NULL; } } } while (!atom); if (!atom) *iRet = 2; // no atom found == end of file else if (atom->Ter) *iRet = 1; // 'ter' card encountered else if (atom->Het) *iRet = 3; // 'hetatm' card encountered else *iRet = 0; // advance ok; normal return } else { // in the output file, just advance the pointer if (Channel[k]->fPos==0) { Channel[k]->fPos++; *iRet = 0; } else { atom = Channel[k]->GetAtomI ( Channel[k]->fPos ); if (atom) { // the previous atom was set -- advance the pointer Channel[k]->fPos++; *iRet = 0; } else // no atom was set; make no advancement *iRet = RWBERR_NoAdvance; } } LastRC = *iRet; } FORTRAN_SUBR ( MMDB_F_REWD, mmdb_f_rewd, ( int * iUnit, int * iRet ), ( int * iUnit, int * iRet ), ( int * iUnit, int * iRet ) ) { int k; strcpy ( LastFunc,"MMDB_F_Rewd" ); LastUnit = *iUnit; k = GetChannel ( *iUnit ); if (k>=0) { Channel[k]->fPos = 0; if (Channel[k]->nRead!=0) *iRet = RWBWAR_RewOutput; else *iRet = RWBERR_Ok; } else *iRet = RWBERR_NoChannel; LastRC = *iRet; } FORTRAN_SUBR ( MMDB_F_BKSP, mmdb_f_bksp, ( int * iUnit, int * iRet ), ( int * iUnit, int * iRet ), ( int * iUnit, int * iRet ) ) { int k; strcpy ( LastFunc,"MMDB_F_BkSp" ); LastUnit = *iUnit; k = GetChannel ( *iUnit ); if (k>=0) { *iRet = RWBERR_Ok; if (Channel[k]->fPos==0) *iRet |= RWBWAR_FileTop; else Channel[k]->fPos--; if (Channel[k]->nRead!=0) *iRet |= RWBWAR_RewOutput; } else *iRet = RWBERR_NoChannel; LastRC = *iRet; } FORTRAN_SUBR ( MMDB_F_SEEK, mmdb_f_seek, ( // lengths-at-end list int * iUnit, // unit number int * fPos, // position to set int * iRet // return code: // 0 Ok // 1 'ter' card met // 2 end of file // 3 'hetatm' card met // <0 error: // RWBERR_NoChannel // iUnit was not // initialized // RWBERR_EmptyPointer // fPos-th position ), ( // lengths-in-structure list int * iUnit, int * fPos, int * iRet ), ( // lengths-follow list int * iUnit, int * fPos, int * iRet ) ) { int k; PCAtom atom; strcpy ( LastFunc,"MMDB_F_Seek" ); LastUnit = *iUnit; k = GetChannel ( *iUnit ); if (k<0) *iRet = RWBERR_NoChannel; else { // set the pointer Channel[k]->fPos = IMax(0,*fPos); if (*fPos==0) *iRet = RWBWAR_FileTop; else *iRet = RWBERR_Ok; if (Channel[k]->nRead==0) { // in the input file, check the end-of-file state // and analyze the atom if (Channel[k]->EndOfFile()) *iRet = 2; atom = Channel[k]->GetAtomI ( Channel[k]->fPos ); if (!atom) *iRet = RWBERR_EmptyPointer; // empty place else if (atom->Ter) *iRet = 1; // 'ter' card encountered else if (atom->Het) *iRet = 3; // 'hetatm' card encountered } // in the output file, there is nothing to do } LastRC = *iRet; } void Make_AN_ID_IZ ( PCAtom atom, pstr AtNam, int AtNam_L, pstr ID, int ID_L, int * IZ, int * iRet ) { char chrg[10]; int i,k; if (atom->Ter) { strcpy_ns ( AtNam,pstr(" "),AtNam_L ); strcpy_ns ( ID ,pstr(" "),ID_L ); *IZ = 7; } else { if (atom->name[0]==' ') strcpy_ns ( AtNam,&(atom->name[1]),4 ); else strcpy_ns ( AtNam,atom->name,4 ); // first try to identify the atom with the element name strcpy_ns ( ID,atom->element,ID_L ); // not more than ID_L symbols // from element until but not including // the terminated null are copied into // ID, and the latter is padded with // spaces up to the length of ID_L if (ID_L>3) { // if length permits, add ID with atom charge // (always 2 symbols). atom->GetAtomCharge(chrg); ID[2] = chrg[0]; ID[3] = chrg[1]; } k = 0; while ((kelement[0]!=ElementName[k][0]) || (atom->element[1]!=ElementName[k][1]))) k++; if (k>=nElementNames) { // no match for atom ID -- make sure to set it blank strcpy_ns ( ID,pstr(" "),ID_L ); // try to identify the atom using the atom name k = 0; while ((kname[0]!=ElementName[k][0]) || (atom->name[1]!=ElementName[k][1]))) k++; // try to identify a heteroatom i = 0; while ((i=nElementNames)) { if ((atom->name[0]==HydAtomName[i][0]) && (atom->name[1]==HydAtomName[i][1])) k = 0; i++; } if (k>=nElementNames) { // unknown or ambiguous formfactor k = -1; if ((atom->name[0]==' ') && (atom->name[1]=='A')) k = 6; if (k==-1) *iRet |= RWBWAR_UnkFormFactor; else *iRet |= RWBWAR_AmbFormFactor; } } *IZ = k+1; if (*IZ==0) strcpy_ns ( ID,pstr(" "),ID_L ); else { if (ID_L>3) { if (ID[0]==' ') { if ((AtNam[2]=='+') || (AtNam[2]=='-')) { ID[2] = AtNam[2]; ID[3] = AtNam[3]; } } else if ((ID[2]!='+') && (ID[2]!='-')) { ID[2] = ' '; ID[3] = ' '; } } strcpy_ns ( ID,ElementName[k],IMin(2,ID_L) ); } } } FORTRAN_SUBR ( MMDB_F_ATOM, mmdb_f_atom, ( // lengths-at-end list int * iUnit, // unit number int * iSer, // atom serial number fpstr AtNam, // atom name (left justified) fpstr ResNam, // residue name fpstr ChnNam, // chain name int * iResN, // residue number as an integer fpstr ResNo, // residue number as character (input only) fpstr InsCod, // the insertion code fpstr AltCod, // the alternate conformation code fpstr segID, // segment ID int * IZ, // atomic number (input only, returned as // 7 from ambiguous atoms) fpstr ID, // atomic ID related to atomic number // (element symbol right justified), plus // the ionic state +2, +3 etc.. // int * iRet, // returns // RWBERR_NoChannel if iUnit was not // initialized // RWBERR_EmptyPointer if atom was not // advanced // RWBERR_Error1 internal error #1 // RWBERR_Error2 internal error #2 // RWBERR_Error3 internal error #3 // // >=0 : success, warning flags: // RWBWAR_WrongSerial if serial number // differs from the position // number in the file // RWBWAR_UnkFormFactor unknown formfactor // RWBWAR_AmbFormFactor ambiguous formfactor // int AtNam_len, // fortran-hidden length of AtNam int ResNam_len, // fortran-hidden length of ResNam int ChnNam_len, // fortran-hidden length of ChnNam int ResNo_len, // fortran-hidden length of ResNo int InsCod_len, // fortran-hidden length of InsCod int AltCod_len, // fortran-hidden length of AltCod int segID_len, // fortran-hidden length of SegID int ID_len // fortran-hidden length of ID ), ( // lengths-in-structure list int * iUnit, int * iSer, fpstr AtNam, fpstr ResNam, fpstr ChnNam, int * iResN, fpstr ResNo, fpstr InsCod, fpstr AltCod, fpstr segID, int * IZ, fpstr ID, int * iRet ), ( // lengths-follow list int * iUnit, int * iSer, fpstr AtNam, int AtNam_len, fpstr ResNam, int ResNam_len, fpstr ChnNam, int ChnNam_len, int * iResN, fpstr ResNo, int ResNo_len, fpstr InsCod, int InsCod_len, fpstr AltCod, int AltCod_len, fpstr segID, int segID_len, int * IZ, fpstr ID, int ID_len, int * iRet ) ) { int k,RC; ChainID chainID; ResName resName; InsCode insCode; AtomName atomName; AltLoc altLoc; SegID sgID; Element element; PCAtom atom; char charge[10]; strcpy ( LastFunc,"MMDB_F_Atom" ); LastUnit = *iUnit; k = GetChannel ( *iUnit ); if (k<0) { *iRet = RWBERR_NoChannel; LastRC = *iRet; return; } *iRet = RWBERR_Ok; if (Channel[k]->nRead==0) { // reading the atom characteristics atom = Channel[k]->GetAtomI ( Channel[k]->fPos ); if (!atom) { // atom position was not advanced properly *iRet = RWBERR_EmptyPointer; LastRC = *iRet; return; } *iSer = atom->serNum; if (*iSer!=Channel[k]->fPos) *iRet |= RWBWAR_WrongSerial; LastSer = *iSer; Make_AN_ID_IZ ( atom,FTN_STR(AtNam),FTN_LEN(AtNam), FTN_STR(ID),FTN_LEN(ID),IZ,iRet ); if (atom->residue) { strcpy_ns ( FTN_STR(ResNam),atom->residue->name,FTN_LEN(ResNam) ); *iResN = atom->residue->seqNum; PutInteger ( FTN_STR(ResNo),*iResN,IMin(4,FTN_LEN(ResNo)) ); strcpy_ns ( FTN_STR(InsCod),atom->residue->insCode,FTN_LEN(InsCod) ); strcpy_ns ( &(FTN_STR(ResNo)[4]),FTN_STR(InsCod),FTN_LEN(ResNo)-4 ); strcpy_ns ( FTN_STR(ChnNam),atom->GetChainID(),FTN_LEN(ChnNam) ); } else { strcpy_ns ( FTN_STR(ResNam),pstr(" "),FTN_LEN(ResNam) ); strcpy_ns ( FTN_STR(ChnNam),pstr(" ") ,FTN_LEN(ChnNam) ); *iResN = 0; strcpy_ns ( FTN_STR(ResNo) ,pstr("0") ,FTN_LEN(ResNo) ); strcpy_ns ( FTN_STR(InsCod),pstr(" ") ,FTN_LEN(InsCod) ); } strcpy_ns ( FTN_STR(AltCod),atom->altLoc,FTN_LEN(AltCod) ); strcpy_ns ( FTN_STR(segID) ,atom->segID ,FTN_LEN(segID) ); } else { // storing the atom characteristics if (!Channel[k]->MMDBManager) { *iRet = RWBERR_Error1; // should never happen LastRC = *iRet; return; } GetStrTer ( chainID,FTN_STR(ChnNam),1,sizeof(chainID),FTN_LEN(ChnNam) ); GetStrTer ( resName,FTN_STR(ResNam),3,sizeof(resName),FTN_LEN(ResNam) ); GetStrTer ( insCode,FTN_STR(InsCod),1,sizeof(insCode),FTN_LEN(InsCod) ); GetStrTer ( altLoc ,FTN_STR(AltCod),1,sizeof(altLoc) ,FTN_LEN(AltCod) ); GetStrTer ( sgID ,FTN_STR(segID) ,4,sizeof(sgID) ,FTN_LEN(segID) ); element[0] = FTN_STR(ID)[0]; element[1] = FTN_STR(ID)[1]; element[2] = char(0); if (FTN_LEN(ID)>3) { charge [0] = FTN_STR(ID)[2]; charge [1] = FTN_STR(ID)[3]; charge [2] = char(0); } else charge [0] = char(0); if (FTN_STR(ID)[0]==' ') { atomName[0] = char(0); // if ((FTN_STR(AtNam)[1]=='H') || // ((FTN_STR(AtNam)[1]=='D') && (FTN_STR(ID)[2]=='D'))) { // int i = 0; // while ((iMMDBManager->PutAtom ( Channel[k]->fPos,*iSer, atomName,resName,chainID,*iResN, insCode,altLoc,sgID,element ); if (RC) { *iRet = RWBERR_Error2; // should never happen LastRC = *iRet; return; } DelSpaces ( charge ); if (charge[0]) { atom = Channel[k]->GetAtomI ( Channel[k]->fPos ); if (!atom) { *iRet = RWBERR_EmptyPointer; // should never be so LastRC = *iRet; return; } atom->SetCharge ( charge ); } if (*iSer!=Channel[k]->fPos) { *iRet |= RWBWAR_WrongSerial; // this is not the right thing at all atom = Channel[k]->GetAtomI ( Channel[k]->fPos ); if (!atom) { *iRet = RWBERR_EmptyPointer; // should never be so LastRC = *iRet; return; } // atom->serNum = *iSer; // - we allow for a mess in serials } LastSer = *iSer; } LastRC = *iRet; } FORTRAN_SUBR ( MMDB_F_SETTER, mmdb_f_setter, ( int * iUnit, int * iRet ), ( int * iUnit, int * iRet ), ( int * iUnit, int * iRet ) ) { int k; PCAtom atom; strcpy ( LastFunc,"MMDB_F_SetTer" ); LastUnit = *iUnit; k = GetChannel ( *iUnit ); if (k<0) { *iRet = RWBERR_NoChannel; LastRC = *iRet; return; } atom = Channel[k]->GetAtomI ( Channel[k]->fPos ); *iRet = RWBERR_Ok; if (!atom) { *iRet = RWBERR_EmptyPointer; // atom position was not advanced properly LastRC = *iRet; return; } atom->Ter = True; atom->WhatIsSet |= ASET_Coordinates; } FORTRAN_SUBR ( MMDB_F_SETHET, mmdb_f_sethet, ( int * iUnit, int * iRet ), ( int * iUnit, int * iRet ), ( int * iUnit, int * iRet ) ) { int k; PCAtom atom; strcpy ( LastFunc,"MMDB_F_SetHet" ); LastUnit = *iUnit; k = GetChannel ( *iUnit ); if (k<0) { *iRet = RWBERR_NoChannel; LastRC = *iRet; return; } atom = Channel[k]->GetAtomI ( Channel[k]->fPos ); *iRet = RWBERR_Ok; if (!atom) { *iRet = RWBERR_EmptyPointer; // atom position was not advanced properly LastRC = *iRet; return; } atom->Het = True; atom->WhatIsSet |= ASET_Coordinates; } FORTRAN_SUBR ( MMDB_F_GETHET, mmdb_f_gethet, ( int * iUnit, int * isHet, int * iRet ), ( int * iUnit, int * isHet, int * iRet ), ( int * iUnit, int * isHet, int * iRet ) ) { int k; PCAtom atom; strcpy ( LastFunc,"MMDB_F_GetHet" ); LastUnit = *iUnit; *isHet = 0; // no HETATM record k = GetChannel ( *iUnit ); if (k<0) { *iRet = RWBERR_NoChannel; LastRC = *iRet; return; } atom = Channel[k]->GetAtomI ( Channel[k]->fPos ); *iRet = RWBERR_Ok; if (!atom) { *iRet = RWBERR_EmptyPointer; // atom position was not advance properly LastRC = *iRet; return; } if (atom->Het) *isHet = 1; // HETATM } FORTRAN_SUBR ( MMDB_F_COPYATOM, mmdb_f_copyatom, ( int * iUnit1, int * iUnit2, int * iRet ), ( int * iUnit1, int * iUnit2, int * iRet ), ( int * iUnit1, int * iUnit2, int * iRet ) ) { int k1,k2,RC; PCAtom atom; strcpy ( LastFunc,"mmdb_f_copyatom" ); LastUnit = *iUnit1; k1 = GetChannel ( *iUnit1 ); if (k1<0) { *iRet = RWBERR_NoChannel; LastRC = *iRet; return; } k2 = GetChannel ( *iUnit2 ); if (k2<0) { *iRet = RWBERR_NoChannel; LastRC = *iRet; return; } atom = Channel[k1]->GetAtomI ( Channel[k1]->fPos ); *iRet = RWBERR_Ok; if (!atom) { *iRet = RWBERR_EmptyPointer; // atom position was not advanced // properly LastRC = *iRet; return; } RC = Channel[k2]->MMDBManager->PutAtom ( Channel[k2]->fPos,atom, atom->serNum ); if (RC) { *iRet = RWBERR_Error2; // should never happen LastRC = *iRet; return; } LastSer = atom->serNum; } FORTRAN_SUBR ( MMDB_F_COORD, mmdb_f_coord, ( // lengths-at-end list int * iUnit, // unit number fpstr XFlag, // "F" or "O" flag for the fractional // or orthogonal coordinates x,y,z // for output files XFlag may also be // set to "HF" or "HO", where "F" and // "O" have the same meaning as before // and "H" indicates that the atom // should be marked as heteroatom fpstr BFlag , // "F" or "O" flag for temperature // factor in fractional or orthogonal // Us apireal * x, // x-coordinate apireal * y, // y-coordinate apireal * z, // z-coordinate apireal * occ, // occupancy apireal * BIso, // isotropic temperature factor apireal * U, // array(6) of the anisotr. t-factor int * iRet, // returns // RWBERR_NoChannel if iUnit was not // initialized // RWBERR_EmptyPointer if atom was not // advanced // RWBERR_NoMatrices if transformation // matrices are // undefined // RWBERR_NoCoordinates if coordinates were // not set in the atom // // >=0 : success, warning flags: // RWBERR_NoOccupancy if occupancy was // not set in the atom // RWBERR_NoTempFactor if temp. factor was // not set in the atom // int XFlag_len, // fortran-hidden length of XFlag int BFlag_len // fortran-hidden length of BFlag ), ( // lengths-in-structure list int * iUnit, fpstr XFlag, fpstr BFlag, apireal * x, apireal * y, apireal * z, apireal * occ, apireal * BIso, apireal * U, int * iRet ), ( // lengths-follow list int * iUnit, fpstr XFlag, int XFlag_len, fpstr BFlag, int BFlag_len, apireal * x, apireal * y, apireal * z, apireal * occ, apireal * BIso, apireal * U, int * iRet ) ) { UNUSED_ARGUMENT(XFlag_len); UNUSED_ARGUMENT(BFlag_len); realtype AU[6]; realtype xx,yy,zz; int k,i,m; PCAtom atom; strcpy ( LastFunc,"MMDB_F_Coord" ); LastUnit = *iUnit; k = GetChannel ( *iUnit ); if (k<0) { *iRet = RWBERR_NoChannel; LastRC = *iRet; return; } atom = Channel[k]->GetAtomI ( Channel[k]->fPos ); *iRet = RWBERR_Ok; if (!atom) { *iRet = RWBERR_EmptyPointer; // atom position was not advanced properly LastRC = *iRet; return; } if ((FTN_STR(XFlag)[0]=='H') || (FTN_STR(XFlag)[0]=='h')) m = 1; else m = 0; if (Channel[k]->nRead==0) { // reading the atomic coordinates if (atom->Ter) { *x = 0.0; *y = 0.0; *z = 0.0; *occ = 1.0; *BIso = 1.0; U[0] = 1.0; U[1] = 0.0; U[2] = 0.0; U[3] = 0.0; U[4] = 0.0; U[5] = 0.0; } else { if (atom->WhatIsSet & ASET_Coordinates) { if ((FTN_STR(XFlag)[m]=='F') || (FTN_STR(XFlag)[m]=='f')) { // receive fractional coordinates if (Channel[k]->areCrystMatrices()) { Channel[k]->Orth2Frac ( atom->x,atom->y,atom->z,xx,yy,zz ); *x = (apireal)xx; *y = (apireal)yy; *z = (apireal)zz; } else { *x = (apireal)atom->x; *y = (apireal)atom->y; *z = (apireal)atom->z; *iRet = RWBERR_NoMatrices; } } else { // receive orthogonal coordinates *x = (apireal)atom->x; *y = (apireal)atom->y; *z = (apireal)atom->z; } } else { *x = 0.0; *y = 0.0; *z = 0.0; *iRet = RWBERR_NoCoordinates; } // calculate isotropic Uf from Uo, and convert it // if necessary if (atom->WhatIsSet & ASET_Anis_tFac) { AU[0] = atom->u11; // this intermediate array is AU[1] = atom->u22; // required because of possible AU[2] = atom->u33; // type difference between AU[3] = atom->u12; // 'apireal' and 'realtype' AU[4] = atom->u13; AU[5] = atom->u23; *BIso = (apireal)(8.0*Pi*Pi*(AU[0]+AU[1]+AU[2])/3.0); if ((FTN_STR(BFlag)[0]=='F') || (FTN_STR(BFlag)[0]=='f')) { if (Channel[k]->areCrystMatrices()) Channel[k]->Orth2Cryst ( AU ); else if (*iRet==RWBERR_Ok) *iRet = RWBERR_NoMatrices; } for (i=0;i<6;i++) U[i] = (apireal)AU[i]; } else { for (i=0;i<6;i++) U[i] = 0.0; if (atom->WhatIsSet & ASET_tempFactor) U[0] = (apireal)atom->tempFactor; else if (*iRet>=RWBERR_Ok) *iRet |= RWBWAR_NoTempFactor; *BIso = U[0]; } // get occupancy now if (atom->WhatIsSet & ASET_Occupancy) *occ = (apireal)atom->occupancy; else { *occ = 0.0; if (*iRet>=RWBERR_Ok) *iRet |= RWBWAR_NoOccupancy; } } } else { // storing the atomic coordinates if (atom->Ter) { atom->x = 0.0; atom->y = 0.0; atom->z = 0.0; atom->WhatIsSet |= ASET_Coordinates; atom->occupancy = 1.0; atom->tempFactor = 1.0; atom->u11 = 0.0; atom->u22 = 0.0; atom->u33 = 0.0; atom->u12 = 0.0; atom->u13 = 0.0; atom->u23 = 0.0; } else { if ((FTN_STR(XFlag)[m]=='F') || (FTN_STR(XFlag)[m]=='f')) { // convert fractional coordinates if (Channel[k]->areCrystMatrices()) { xx = *x; yy = *y; zz = *z; Channel[k]->Frac2Orth ( xx,yy,zz,atom->x,atom->y,atom->z ); atom->WhatIsSet |= ASET_Coordinates; } else { atom->x = *x; atom->y = *y; atom->z = *z; *iRet = RWBERR_NoMatrices; atom->WhatIsSet &= ~ASET_Coordinates; } } else { // store orthogonal coordinates atom->x = *x; atom->y = *y; atom->z = *z; atom->WhatIsSet |= ASET_Coordinates; } atom->Het = (m>0); // calculate isotropic Uf from Uo, and convert it // if necessary if ((U[1]!=0.0) || (U[2]!=0.0)) { for (i=0;i<6;i++) AU[i] = U[i]; if ((FTN_STR(BFlag)[0]=='F') || (FTN_STR(BFlag)[0]=='f')) { if (Channel[k]->areCrystMatrices()) Channel[k]->Cryst2Orth ( AU ); else *iRet = RWBERR_NoMatrices; } *BIso = (apireal)(8.0*Pi*Pi*(AU[0]+AU[1]+AU[2])/3.0); atom->tempFactor = *BIso; atom->u11 = AU[0]; atom->u22 = AU[1]; atom->u33 = AU[2]; atom->u12 = AU[3]; atom->u13 = AU[4]; atom->u23 = AU[5]; atom->WhatIsSet |= ASET_tempFactor | ASET_Anis_tFac; } else { *BIso = U[0]; atom->tempFactor = *BIso; atom->u11 = 0.0; atom->u22 = 0.0; atom->u33 = 0.0; atom->u12 = 0.0; atom->u13 = 0.0; atom->u23 = 0.0; atom->WhatIsSet |= ASET_tempFactor; } // store occupancy now atom->occupancy = *occ; atom->WhatIsSet |= ASET_Occupancy; } } LastRC = *iRet; } FORTRAN_SUBR ( MMDB_F_SETCELL, mmdb_f_setcell, ( // lengths-at-end list int * iUnit, // unit number apireal * a, // cell parameter a, angstroms apireal * b, // cell parameter b, angstroms apireal * c, // cell parameter c, angstroms apireal * alpha, // cell parameter alpha, degrees apireal * beta, // cell parameter beta, degrees apireal * gamma, // cell parameter gamma, degrees int * ArgNCode, // orthogonalization code, 1-6 int * iRet // return code: // RWBERR_Ok - success // RWBERR_NoChannel if unit // iUnit was not // initialized // RWBERR_NoFile if unit // has been disposed // RWBERR_Disagreement if a // disagreement in // cell parameters // was found // RWBERR_NoOrthCode if no // orthogonalization // code was found // RWBERR_NoCheck if check // of cell parameters // has failed. // The last three returns would // rather indicate a programming // error in mmdb_rwbrook.cpp ), ( // lengths-in-structure list int * iUnit, apireal * a, apireal * b, apireal * c, apireal * alpha, apireal * beta, apireal * gamma, int * ArgNCode, int * iRet ), ( // lengths-follow list int * iUnit, apireal * a, apireal * b, apireal * c, apireal * alpha, apireal * beta, apireal * gamma, int * ArgNCode, int * iRet ) ) { int k; strcpy ( LastFunc,"MMDB_F_SetCell" ); if (*iUnit>0) LastUnit = *iUnit; k = GetChannel ( LastUnit ); if (k<0) *iRet = RWBERR_NoChannel; else *iRet = Channel[k]->SetCell ( *a,*b,*c,*alpha,*beta,*gamma, *ArgNCode ); LastRC = *iRet; } FORTRAN_SUBR ( MMDB_F_WBSPGRP, mmdb_f_wbspgrp, ( // lengths-at-end list int * iUnit, // unit number; *iUnit<=0 means // "the last mentioned unit" fpstr spGroup, // space group int * iRet, // return code: // RWBERR_Ok - success // RWBERR_NoChannel if unit // iUnit was not // initialized // RWBERR_NoFile if unit // has been disposed int spGroup_len // fortran-hidden length of spGroup ), ( // lengths-in-structure list int * iUnit, fpstr spGroup, int * iRet ), ( // lengths-follow list int * iUnit, fpstr spGroup, int spGroup_len, int * iRet ) ) { int k; SymGroup spaceGroup; strcpy ( LastFunc,"MMDB_F_WBSpGrp" ); if (*iUnit>0) LastUnit = *iUnit; k = GetChannel ( LastUnit ); if (k<0) *iRet = RWBERR_NoChannel; else { // GetStrTer ( spaceGroup,FTN_STR(spGroup),0, // sizeof(spaceGroup),FTN_LEN(spGroup) ); strcpy_ncss(spaceGroup,FTN_STR(spGroup),IMin(FTN_LEN(spGroup), sizeof(spaceGroup)-1) ); *iRet = Channel[k]->SetSpGroup ( spaceGroup ); } LastRC = *iRet; } FORTRAN_SUBR ( MMDB_F_RBSPGRP, mmdb_f_rbspgrp, ( // lengths-at-end list int * iUnit, // unit number; *iUnit<=0 means // "the last mentioned unit" fpstr spGroup, // space group int * iRet, // return code: // RWBERR_Ok - success // RWBERR_NoChannel if unit // iUnit was not // initialized // RWBERR_NoFile if unit // has been disposed int spGroup_len // fortran-hidden length of spGroup ), ( // lengths-in-structure list int * iUnit, fpstr spGroup, int * iRet ), ( // lengths-follow list int * iUnit, fpstr spGroup, int spGroup_len, int * iRet ) ) { int k; char SpaceGroup[100]; strcpy ( LastFunc,"MMDB_F_RBSpGrp" ); if (*iUnit>0) LastUnit = *iUnit; SpaceGroup[0] = char(0); k = GetChannel ( LastUnit ); if (k<0) *iRet = RWBERR_NoChannel; else *iRet = Channel[k]->GetSpGroup ( SpaceGroup ); // all extra "superficial spaces" are killed in the following CutSpaces ( SpaceGroup,SCUTKEY_BEGEND ); strcpy_ns ( FTN_STR(spGroup),SpaceGroup,FTN_LEN(spGroup) ); LastRC = *iRet; } FORTRAN_SUBR ( MMDB_F_WBCELL , mmdb_f_wbcell, ( // lengths-at-end list int * iUnit, // unit number; *iUnit<=0 means // "the last mentioned unit" apireal * ArgCell, // array to accept the cell parameters // if ArgCell(1) is set to 0, then // the cell does not change int * ArgNCode, // orthogonalisation code // if ArgNCode is set to 0, then // the orthogonalisation matrices // do not change int * iRet // return code // RWBERR_Ok - success // RWBERR_NoChannel if unit // iUnit was not // initialized // RWBERR_NoFile if unit // has been disposed ), ( // lengths-in-structure list int * iUnit, apireal * ArgCell, int * ArgNCode, int * iRet ), ( // lengths-follow list int * iUnit, apireal * ArgCell, int * ArgNCode, int * iRet ) ) { int k; strcpy ( LastFunc,"MMDB_F_WBCell" ); if (*iUnit>0) LastUnit = *iUnit; k = GetChannel ( LastUnit ); if (k<0) *iRet = RWBERR_NoChannel; else *iRet = Channel[k]->PutCell ( ArgCell[0],ArgCell[1],ArgCell[2], ArgCell[3],ArgCell[4],ArgCell[5], *ArgNCode ); LastRC = *iRet; } FORTRAN_SUBR ( MMDB_F_RBCELL, mmdb_f_rbcell, ( // lengths-at-end list int * iUnit, // unit number apireal * celld, // array to accept the cell parameters apireal * cvol, // returns the cell volume int * iRet // return code // RWBERR_Ok - success // RWBERR_NoChannel if unit // iUnit was not // initialized // RWBERR_NoFile if unit // has been disposed // RWBERR_Parameters if the // cell parameters // were not set // RWBERR_NoOrthCode if no // orthogonalization // code was found // RWBERR_NoCheck if check // of cell parameters // has failed. // The last three returns would // rather indicate a programming // error in mmdb_rwbrook.cpp ), ( // lengths-in-structure list int * iUnit, apireal * celld, apireal * cvol, int * iRet ), ( // lengths-follow list int * iUnit, apireal * celld, apireal * cvol, int * iRet ) ) { realtype p[6]; realtype v; int k,i,nc; strcpy ( LastFunc,"MMDB_F_RBCell" ); if (*iUnit>0) LastUnit = *iUnit; k = GetChannel ( LastUnit ); if (k<0) { *iRet = RWBERR_NoChannel; LastRC = *iRet; return; } *iRet = Channel[k]->GetCell ( p[0],p[1],p[2],p[3],p[4],p[5],v,nc ); if (*iRet==RWBERR_Ok) { for (i=0;i<6;i++) celld[i] = (apireal)p[i]; *cvol = (apireal)v; } LastRC = *iRet; } FORTRAN_SUBR ( MMDB_F_RBCELLN, mmdb_f_rbcelln, ( // lengths-at-end list int * iUnit, // unit number apireal * celld, // array to accept the cell parameters apireal * cvol, // returns the cell volume int * ArgNCode, // returns the orthogonalization code, 1-6 int * iRet // return code // RWBERR_Ok - success // RWBERR_NoChannel if unit // iUnit was not // initialized // RWBERR_NoFile if unit // has been disposed // RWBERR_Parameters if the // cell parameters // were not set // RWBERR_NoOrthCode if no // orthogonalization // code was found // RWBERR_NoCheck if check // of cell parameters // has failed. // The last three returns would // rather indicate a programming // error in mmdb_rwbrook.cpp ), ( // lengths-in-structure list int * iUnit, apireal * celld, apireal * cvol, int * ArgNCode, int * iRet ), ( // lengths-follow list int * iUnit, apireal * celld, apireal * cvol, int * ArgNCode, int * iRet ) ) { realtype p[6]; realtype v; int k,i,nc; strcpy ( LastFunc,"MMDB_F_RBCellN" ); if (*iUnit>0) LastUnit = *iUnit; k = GetChannel ( LastUnit ); if (k<0) { *iRet = RWBERR_NoChannel; LastRC = *iRet; return; } *iRet = Channel[k]->GetCell ( p[0],p[1],p[2],p[3],p[4],p[5],v,nc ); if (*iRet==RWBERR_Ok) { for (i=0;i<6;i++) celld[i] = (apireal)p[i]; *cvol = (apireal)v; *ArgNCode = nc; } LastRC = *iRet; } FORTRAN_SUBR ( MMDB_F_RBRCEL, mmdb_f_rbrcel, ( // lengths-at-end list int * iUnit, // unit number apireal * rcell, // array to accept the reciprocal // cell parameters apireal * rvol, // returns the reciprocal cell volume int * iRet // return code // RWBERR_Ok - success // RWBERR_NoChannel if unit // iUnit was not // initialized // RWBERR_NoFile if unit // has been disposed // RWBERR_Parameters if the // cell parameters // were not set // RWBERR_NoOrthCode if no // orthogonalization // code was found // RWBERR_NoCheck if check // of cell parameters // has failed. // The last three returns would // rather indicate a programming // error in mmdb_rwbrook.cpp ), ( // lengths-in-structure list int * iUnit, apireal * rcell, apireal * rvol, int * iRet ), ( // lengths-follow list int * iUnit, apireal * rcell, apireal * rvol, int * iRet ) ) { realtype p[6]; realtype v; int k,i; strcpy ( LastFunc,"MMDB_F_RBRCel" ); if (*iUnit>0) LastUnit = *iUnit; k = GetChannel ( LastUnit ); if (k<0) { *iRet = RWBERR_NoChannel; LastRC = *iRet; return; } *iRet = Channel[k]->GetRCell ( p[0],p[1],p[2],p[3],p[4],p[5],v ); if (*iRet==RWBERR_Ok) { for (i=0;i<6;i++) rcell[i] = (apireal)p[i]; *rvol = (apireal)v; } LastRC = *iRet; } FORTRAN_SUBR ( MMDB_F_RBORF, mmdb_f_rborf, ( // lengths-at-end list int * iUnit, // unit number apireal * RO, // array for orthogonalising matrix apireal * RF, // array for fractionalising matrix int * LCode, // buffer for orthogonalisation code int * iRet // return code: // RWBERR_Ok - success // RWBERR_NoChannel if unit // iUnit was not // initialized // RWBERR_NoFile if unit // has been disposed // RWBERR_NoMatrices if the // orthogonalisation // matrices were not // calculated ), ( // lengths-in-structure list int * iUnit, apireal * RO, apireal * RF, int * LCode, int * iRet ), ( // lengths-follow list int * iUnit, apireal * RO, apireal * RF, int * LCode, int * iRet ) ) { int i,j,k,l; PCMMDBCryst Cryst; strcpy ( LastFunc,"MMDB_F_RBORF" ); if (*iUnit>0) LastUnit = *iUnit; k = GetChannel ( LastUnit ); if (k<0) { *iRet = RWBERR_NoChannel; LastRC = *iRet; return; } Cryst = Channel[k]->GetCryst(); if (Cryst==NULL) { *iRet = RWBERR_NoFile; LastRC = *iRet; return; } *iRet = RWBERR_Ok; l = 0; if (RO[0]<=0.0000000001) { for (j=0;j<4;j++) for (i=0;i<4;i++) { RF[l] = (apireal)Cryst->RF[i][j]; RO[l] = (apireal)Cryst->RO[i][j]; l++; } *LCode = Cryst->NCode; if (!(Cryst->WhatIsSet & CSET_Transforms)) *iRet = RWBERR_NoMatrices; } else { for (j=0;j<4;j++) for (i=0;i<4;i++) { Cryst->RF[i][j] = RF[l]; Cryst->RO[i][j] = RO[l]; l++; } Cryst->NCode = *LCode; Cryst->WhatIsSet |= CSET_Transforms; } LastRC = *iRet; } FORTRAN_SUBR ( MMDB_F_ORTHMAT, mmdb_f_orthmat, ( // lengths-at-end list int * iUnit, // unit number; *iUnit<=0 means // "the last mentioned unit" apireal * Cell, // array of cell parameters: // Cell(1) - a Cell(4) - alpha // Cell(2) - b Cell(5) - beta // Cell(3) - c Cell(6) - gamma apireal * Vol, // returns cell volume apireal * RRR, // array (3,3,6), returns // orthogonalisation matrices int * iRet // return code: // RWBERR_Ok - success // RWBERR_NoChannel if unit // iUnit was not // initialized // RWBERR_NoFile if unit // has been disposed // RWBERR_NoMatrices if the // orthogonalisation // matrices were not // calculated ), ( // lengths-in-structure list int * iUnit, apireal * Cell, apireal * Vol, apireal * RRR, int * iRet ), ( // lengths-follow list int * iUnit, apireal * Cell, apireal * Vol, apireal * RRR, int * iRet ) ) { int i,j,k,l,m; PCMMDBCryst Cryst; realtype CelDel; strcpy ( LastFunc,"MMDB_F_OrthMat" ); if (*iUnit>0) LastUnit = *iUnit; k = GetChannel ( LastUnit ); if (k<0) { *iRet = RWBERR_NoChannel; LastRC = *iRet; return; } Cryst = Channel[k]->GetCryst(); if (Cryst==NULL) { *iRet = RWBERR_NoFile; LastRC = *iRet; return; } CelDel = 0.0; if (Cell[0]>0.0) { if ((Cryst->WhatIsSet & CSET_CellParams)==CSET_CellParams) { CelDel = fabs((Cell[0]-Cryst->a)/Cell[0]); if (Cell[1]!=0.0) CelDel = RMax(CelDel,fabs((Cell[1]-Cryst->b)/Cell[1])); if (Cell[2]!=0.0) CelDel = RMax(CelDel,fabs((Cell[2]-Cryst->c)/Cell[2])); if (Cell[3]!=0.0) CelDel = RMax(CelDel,fabs((Cell[3]-Cryst->alpha)/Cell[3])); if (Cell[4]!=0.0) CelDel = RMax(CelDel,fabs((Cell[4]-Cryst->beta )/Cell[4])); if (Cell[5]!=0.0) CelDel = RMax(CelDel,fabs((Cell[5]-Cryst->gamma)/Cell[5])); if (FSimRWBROOK && (CelDel>0.01)) printf ( "\n Inconsistency in Cell Dimensions" " - replacing old:\n" " Old cell: " "%10.5f%10.5f%10.5f%10.5f%10.5f%10.5f\n" " New cell: " "%10.5f%10.5f%10.5f%10.5f%10.5f%10.5f\n", Cryst->a,Cryst->b,Cryst->c, Cryst->alpha,Cryst->beta,Cryst->gamma, Cell[0],Cell[1],Cell[2],Cell[3],Cell[4],Cell[5] ); } Cryst->a = Cell[0]; Cryst->b = Cell[1]; Cryst->c = Cell[2]; Cryst->alpha = Cell[3]; Cryst->beta = Cell[4]; Cryst->gamma = Cell[5]; Cryst->WhatIsSet |= CSET_CellParams; } else { Cell[0] = (apireal)Cryst->a; Cell[1] = (apireal)Cryst->b; Cell[2] = (apireal)Cryst->c; Cell[3] = (apireal)Cryst->alpha; Cell[4] = (apireal)Cryst->beta; Cell[5] = (apireal)Cryst->gamma; } if ((Cryst->WhatIsSet & CSET_CellParams)!=CSET_CellParams) { *iRet = RWBERR_NoCellParams; LastRC = *iRet; return; } *iRet = RWBERR_Ok; // Cryst->CalcOrthMatrices(); <-- old version, changed 09.01.2004 Cryst->CalcCoordTransforms(); Cryst->WhatIsSet |= CSET_Transforms; if (CelDel>0.01) *Vol = -(apireal)Cryst->Vol; else *Vol = (apireal)Cryst->Vol; l = 0; for (j=0;j<3;j++) for (i=0;i<3;i++) for (m=0;m<6;m++) RRR[l++] = (apireal)Cryst->RR[m][j][i]; LastRC = *iRet; } FORTRAN_SUBR ( MMDB_F_CVANISOU, mmdb_f_cvanisou, ( // lengths-at-end list int * iUnit, // unit number; *iUnit<=0 means // "the last mentioned unit" apireal * U, // array of coordinates to convert int * iFlag, // =0: convert from fract. to orthog. // =1: convert from orthog. to fract. int * iRet // return code: // RWBERR_Ok - success // RWBERR_NoChannel if unit // iUnit was not // initialized // RWBERR_NoFile if unit // has been disposed // RWBERR_NoMatrices if the // orthogonalisation // matrices were not // calculated ), ( // lengths-in-structure list int * iUnit, apireal * U, int * iFlag, int * iRet ), ( // lengths-follow list int * iUnit, apireal * U, int * iFlag, int * iRet ) ) { int k,i; PCMMDBCryst Cryst; realtype U1[6]; strcpy ( LastFunc,"MMDB_F_CVAnisou" ); if (*iUnit>0) LastUnit = *iUnit; k = GetChannel ( LastUnit ); if (k<0) { *iRet = RWBERR_NoChannel; LastRC = *iRet; return; } Cryst = Channel[k]->GetCryst(); if (Cryst==NULL) { *iRet = RWBERR_NoFile; LastRC = *iRet; return; } *iRet = RWBERR_Ok; for (i=0;i<6;i++) U1[i] = U[i]; if (iFlag==0) { if (!Cryst->Cryst2Orth(U1)) *iRet = RWBERR_NoMatrices; } else { if (!Cryst->Orth2Cryst(U1)) *iRet = RWBERR_NoMatrices; } if (*iRet==RWBERR_Ok) for (i=0;i<6;i++) U[i] = (apireal)U1[i]; LastRC = *iRet; } FORTRAN_SUBR ( MMDB_F_WREMARK, mmdb_f_wremark, ( // lengths-at-end list int * iUnit, // unit number; *iUnit<=0 means // "the last mentioned unit" fpstr Line, // line to be added int * iRet, // return code: // RWBERR_Ok - success // RWBERR_NoChannel if unit // iUnit was not // initialized // RWBERR_NoFile if unit // has been disposed // other return codea are those // returned by xyzopen1_(..) int Line_len // fortran-hidden length of Line ), ( // lengths-in-structure list int * iUnit, fpstr Line, int * iRet ), ( // lengths-follow list int * iUnit, fpstr Line, int Line_len, int *iRet ) ) { int k; char S[500]; strcpy ( LastFunc,"MMDB_F_WRemark" ); if (*iUnit>0) LastUnit = *iUnit; k = GetChannel ( LastUnit ); if (k<0) { *iRet = RWBERR_NoChannel; LastRC = *iRet; return; } if (Channel[k]->MMDBManager) { GetStrTer ( S,FTN_STR(Line),FTN_LEN(Line),sizeof(S),FTN_LEN(Line) ); *iRet = Channel[k]->MMDBManager->PutPDBString ( S ); } else *iRet = RWBERR_NoFile; LastRC = *iRet; } /* FORTRAN_SUBR ( RBRINV, rbrinv, ( apireal * A, apireal * AI ), ( apireal * A, apireal * AI ), ( apireal * A, apireal * AI ) ) { mat44 A1,AI1; int i,j,k; k = 0; for (j=0;j<4;j++) for (i=0;i<4;i++) A1[j][i] = A[k++]; Mat4Inverse ( A1,AI1 ); k = 0; for (j=0;j<4;j++) for (i=0;i<4;i++) AI[k++] = AI1[j][i]; } */ /* FORTRAN_SUBR ( RES3TO1, res3to1, ( // lengths-at-end list fpstr ResNm3, // 3-char name, 4th char // will be set blank fpstr ResNm1, // 1-char name int ResNm3_len, // fortran-hidden length of ResNm3 int ResNm1_len // fortran-hidden length of ResNm3 ), ( // lengths-in-structure list fpstr ResNm3, fpstr ResNm1 ), ( // lengths-follow list fpstr ResNm3, int ResNm3_len, fpstr ResNm1, int ResNm1_len ) ) { int i; if (FTN_STR(ResNm3)[0]==' ') { for (i=0;i=0) printf ( " *** file : %s\n",Channel[k]->FName ); for (i=0;i0) printf ( " *** position %i, serial number %i\n", Channel[k]->fPos,LastSer ); else printf ( " *** position unavailable, serial number %i\n", LastSer ); } } if (!Msg) printf ( " *** warning: unknown warning code" ); return; } else Msg = MSG_Unknown; } if ((k>=0) && ( ((*iRet<=RWBERR_WrongInteger) && (*iRet>=RWBERR_DuplicatedModel)) || ((*iRet<=RWBERR_ATOM_Unrecognd) && (*iRet>=RWBERR_ATOM_Unmatch)) || ((*iRet<=RWBERR_NoData) && (*iRet>=RWBERR_DuplicateSeqNum)) )) Channel[k]->GetInputBuffer ( ErrLine,lcount ); printf ( " \n *** RWBROOK error: point code unit function\n" ); printf ( " *** %5i %4i %4i %s\n",*iPlace,*iRet, *iUnit,LastFunc ); k = GetChannel(*iUnit); if (k>=0) printf ( " *** file : %s\n",Channel[k]->FName ); printf ( " *** reason : %s\n",Msg ); if (lcount>=0) printf ( " *** at input line #%i:\n" " %s\n",lcount,ErrLine ); else if (lcount==-1) printf ( " *** at taking the following data from CIF:\n" " %s\n",ErrLine ); if (*iStop==0) { // will stop it printf ( " *** Execution stopped.\n \n" ); FORTRAN_CALL ( MMDB_F_QUIT, mmdb_f_quit,(),(),() ); // xyzquit_(); exit(0); } else // just warn, but no guarantee that it will not crash printf ( " *** continue running, may crash ...\n \n" ); } FORTRAN_SUBR ( RBCHECKERR, rbcheckerr, ( // lengths-at-end list int * iPlace, // (unique) identificator inside an application int * iStop // if 0 then stop if error ), ( // lengths-in-structure list int * iPlace, int * iStop ), ( // lengths-follow list int * iPlace, int * iStop ) ) { FORTRAN_CALL ( RBERRSTOP, rberrstop, ( iPlace,&LastRC,&LastUnit,iStop ), ( iPlace,&LastRC,&LastUnit,iStop ), ( iPlace,&LastRC,&LastUnit,iStop ) ); } /* hybrid-36 encoder: converts integer value to string result iwidth: must be 4 (e.g. for residue sequence numbers) or 5 (e.g. for atom serial numbers) value: integer value to be converted strval: char array containing string result */ FORTRAN_SUBR ( HY36ENCODE_F, hy36encode_f, (const int *iwidth, int *value, fpstr strval, int strval_len), (const int *iwidth, int *value, fpstr strval), (const int *iwidth, int *value, fpstr strval, int strval_len)) { unsigned width; char result[6]; width = (unsigned) *iwidth; if (hy36encode(width, *value, result)) { printf("problem in hy36encode_f! \n"); } strcpy_ns(FTN_STR(strval),result,FTN_LEN(strval)); } /* hybrid-36 decoder: converts string s to integer result iwidth: must be 4 (e.g. for residue sequence numbers) or 5 (e.g. for atom serial numbers) strval: string to be converted value: integer holding the conversion result */ FORTRAN_SUBR ( HY36DECODE_F, hy36decode_f, (const int *iwidth, fpstr strval, int *value, int strval_len), (const int *iwidth, fpstr strval, int *value), (const int *iwidth, fpstr strval, int strval_len, int *value)) { UNUSED_ARGUMENT(strval); unsigned width; size_t length = FTN_LEN(strval); char* s; width = (unsigned) *iwidth; s = (char *) malloc((length+1)*sizeof(char)); s[length] = '\0'; if (hy36decode(width, s, width, value)) { printf("problem in hy36decode_f! \n"); } } mmdb-1.25.5/mmdb/mmdb_cryst.cpp0000775000175000017500000016315112106546753013257 00000000000000// $Id: mmdb_cryst.cpp,v 1.27 2012/01/26 17:52:20 ekr Exp $ // ================================================================= // // CCP4 Coordinate Library: support of coordinate-related // functionality in protein crystallography applications. // // Copyright (C) Eugene Krissinel 2000-2008. // // This library is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // // ================================================================= // // 05.02.13 <-- Date of Last Modification. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ----------------------------------------------------------------- // // **** Module : MMDB_Cryst // ~~~~~~~~~ // **** Project : MacroMolecular Data Base (MMDB) // ~~~~~~~~~ // **** Classes : CCrystContainer ( container for cryst. data ) // ~~~~~~~~~ CNCSMatrix ( non-cryst. symm. matrix class ) // CTVect ( translational vector class ) // CMMDBCryst ( MMDB cryst. section class ) // // (C) E. Krissinel 2000-2013 // // ================================================================= // #ifndef __STRING_H #include #endif #ifndef __STDLIB_H #include #endif #ifndef __MATH_H #include #endif #ifndef __MMDB_Cryst__ #include "mmdb_cryst.h" #endif #ifndef __MMDB_Defs__ #include "mmdb_defs.h" #endif #ifndef __MMDB_CIFDefs__ #include "mmdb_cifdefs.h" #endif // ============== CCrystContainer ==================== PCContainerClass CCrystContainer::MakeContainerClass ( int ClassID ) { switch (ClassID) { default : case ClassID_Template : return CClassContainer::MakeContainerClass(ClassID); case ClassID_NCSMatrix : return new CNCSMatrix(); case ClassID_TVect : return new CTVect (); } } int CCrystContainer::AddMTRIXLine ( cpstr S ) { int i,RC; RC = Error_NCSM_WrongSerial; for (i=0;iConvertPDBASCII(S); if (RC==0) break; if (RC!=Error_NCSM_WrongSerial) break; } return RC; } MakeStreamFunctions(CCrystContainer) // ================ CNCSMatrix =================== CNCSMatrix::CNCSMatrix() : CContainerClass() { Init(); } CNCSMatrix::CNCSMatrix ( cpstr S ) : CContainerClass() { Init(); ConvertPDBASCII ( S ); } CNCSMatrix::CNCSMatrix ( RPCStream Object ) : CContainerClass(Object) { Init(); } CNCSMatrix::~CNCSMatrix() {} void CNCSMatrix::Init() { int i,j; serNum = -1; iGiven = -1; for (i=0;i<3;i++) { for (j=0;j<3;j++) m[i][j] = 0.0; m[i][i] = 1.0; v[i] = 0.0; } WhatIsSet = 0; // nothing is set } Boolean CNCSMatrix::PDBASCIIDump1 ( RCFile f ) { // makes the ASCII PDB MATRIXn lines if all // of them were set. char S[100]; int i,j; if ((WhatIsSet & NCSMSET_All)==NCSMSET_All) for (i=0;i<3;i++) { sprintf ( S,"MTRIX%1i %3i",i+1,serNum ); PadSpaces ( S,80 ); for (j=0;j<3;j++) PutRealF ( &(S[10+j*10]),m[i][j],10,6 ); PutRealF ( &(S[45]),v[i],10,5 ); if (iGiven) S[59] = '1'; f.WriteLine ( S ); } return True; // container should use this virtual } int CNCSMatrix::ConvertPDBASCII ( cpstr S ) { int sN,iG; realtype m0,m1,m2,v0; if (!(GetInteger(sN,&(S[7]) ,3 ) && GetReal (m0,&(S[10]),10) && GetReal (m1,&(S[20]),10) && GetReal (m2,&(S[30]),10) && GetReal (v0,&(S[45]),10))) return Error_NCSM_Unrecognized; if (S[59]=='1') iG = 1; else iG = 0; if (WhatIsSet & NCSMSET_All) { if (sN!=serNum) return Error_NCSM_WrongSerial; if (iG!=iGiven) return Error_NCSM_UnmatchIG; } if (!strncmp(S,"MTRIX1",6)) { if (WhatIsSet & NCSMSET_Matrix1) return Error_NCSM_AlreadySet; serNum = sN; iGiven = iG; m[0][0] = m0; m[0][1] = m1; m[0][2] = m2; v[0] = v0; WhatIsSet |= NCSMSET_Matrix1; } else if (!strncmp(S,"MTRIX2",6)) { if (WhatIsSet & NCSMSET_Matrix2) return Error_NCSM_AlreadySet; serNum = sN; iGiven = iG; m[1][0] = m0; m[1][1] = m1; m[1][2] = m2; v[1] = v0; WhatIsSet |= NCSMSET_Matrix2; } else if (!strncmp(S,"MTRIX3",6)) { if (WhatIsSet & NCSMSET_Matrix3) return Error_NCSM_AlreadySet; serNum = sN; iGiven = iG; m[2][0] = m0; m[2][1] = m1; m[2][2] = m2; v[2] = v0; WhatIsSet |= NCSMSET_Matrix3; } else return Error_WrongSection; return 0; } void CNCSMatrix::MakeCIF ( PCMMCIFData CIF, int N ) { PCMMCIFLoop Loop; int RC; RC = CIF->AddLoop ( CIFCAT_STRUCT_NCS_OPER,Loop ); if ((RC!=CIFRC_Ok) || (N==0)) { // the category was (re)created, provide tags Loop->AddLoopTag ( CIFTAG_ID ); Loop->AddLoopTag ( CIFTAG_MATRIX11 ); Loop->AddLoopTag ( CIFTAG_MATRIX12 ); Loop->AddLoopTag ( CIFTAG_MATRIX13 ); Loop->AddLoopTag ( CIFTAG_VECTOR1 ); Loop->AddLoopTag ( CIFTAG_MATRIX21 ); Loop->AddLoopTag ( CIFTAG_MATRIX22 ); Loop->AddLoopTag ( CIFTAG_MATRIX23 ); Loop->AddLoopTag ( CIFTAG_VECTOR2 ); Loop->AddLoopTag ( CIFTAG_MATRIX31 ); Loop->AddLoopTag ( CIFTAG_MATRIX32 ); Loop->AddLoopTag ( CIFTAG_MATRIX33 ); Loop->AddLoopTag ( CIFTAG_VECTOR3 ); Loop->AddLoopTag ( CIFTAG_CODE ); } Loop->AddInteger ( serNum ); if (WhatIsSet & NCSMSET_Matrix1) { Loop->AddReal ( m[0][0] ); Loop->AddReal ( m[0][1] ); Loop->AddReal ( m[0][2] ); Loop->AddReal ( v[0] ); } else { Loop->AddString ( NULL ); Loop->AddString ( NULL ); Loop->AddString ( NULL ); Loop->AddString ( NULL ); } if (WhatIsSet & NCSMSET_Matrix2) { Loop->AddReal ( m[1][0] ); Loop->AddReal ( m[1][1] ); Loop->AddReal ( m[1][2] ); Loop->AddReal ( v[1] ); } else { Loop->AddString ( NULL ); Loop->AddString ( NULL ); Loop->AddString ( NULL ); Loop->AddString ( NULL ); } if (WhatIsSet & NCSMSET_Matrix3) { Loop->AddReal ( m[2][0] ); Loop->AddReal ( m[2][1] ); Loop->AddReal ( m[2][2] ); Loop->AddReal ( v[2] ); } else { Loop->AddString ( NULL ); Loop->AddString ( NULL ); Loop->AddString ( NULL ); Loop->AddString ( NULL ); } if (iGiven==1) Loop->AddString ( pstr("generated") ); else Loop->AddNoData ( CIF_NODATA_DOT ); } void CNCSMatrix::GetCIF ( PCMMCIFData CIF, int & Signal ) { PCMMCIFLoop Loop; char Code[100]; Loop = CIF->GetLoop ( CIFCAT_STRUCT_NCS_OPER ); if (!Loop) { Signal = -1; // signal to finish processing of this structure return; } if (Signal>=Loop->GetLoopLength()) { Signal = -1; return; } WhatIsSet = 0; if (CIFGetInteger(serNum,Loop,CIFTAG_ID,Signal)) return; if (CIFGetString(Code,Loop,CIFTAG_CODE,Signal,sizeof(Code), pstr(""))) iGiven = MinInt4; else if (!strcasecmp(Code,"generated")) iGiven = 1; else iGiven = MinInt4; if (CIFGetReal(m[0][0],Loop,CIFTAG_MATRIX11,Signal)) return; if (CIFGetReal(m[0][1],Loop,CIFTAG_MATRIX12,Signal)) return; if (CIFGetReal(m[0][2],Loop,CIFTAG_MATRIX13,Signal)) return; if (CIFGetReal(v[0] ,Loop,CIFTAG_VECTOR1 ,Signal)) return; WhatIsSet |= NCSMSET_Matrix1; if (CIFGetReal(m[1][0],Loop,CIFTAG_MATRIX21,Signal)) return; if (CIFGetReal(m[1][1],Loop,CIFTAG_MATRIX22,Signal)) return; if (CIFGetReal(m[1][2],Loop,CIFTAG_MATRIX23,Signal)) return; if (CIFGetReal(v[1] ,Loop,CIFTAG_VECTOR2 ,Signal)) return; WhatIsSet |= NCSMSET_Matrix2; if (CIFGetReal(m[2][0],Loop,CIFTAG_MATRIX31,Signal)) return; if (CIFGetReal(m[2][1],Loop,CIFTAG_MATRIX32,Signal)) return; if (CIFGetReal(m[2][2],Loop,CIFTAG_MATRIX33,Signal)) return; if (CIFGetReal(v[2] ,Loop,CIFTAG_VECTOR3 ,Signal)) return; WhatIsSet |= NCSMSET_Matrix3; Signal++; } void CNCSMatrix::SetNCSMatrix ( int serialNum, mat33 & ncs_m, vect3 & ncs_v, int i_Given ) { int i,j; serNum = serialNum; for (i=0;i<3;i++) { for (j=0;j<3;j++) m[i][j] = ncs_m[i][j]; v[i] = ncs_v[i]; } iGiven = i_Given; WhatIsSet |= NCSMSET_All; } void CNCSMatrix::Copy ( PCContainerClass NCSMatrix ) { int i,j; serNum = PCNCSMatrix(NCSMatrix)->serNum; iGiven = PCNCSMatrix(NCSMatrix)->iGiven; for (i=0;i<3;i++) { for (j=0;j<3;j++) m[i][j] = PCNCSMatrix(NCSMatrix)->m[i][j]; v[i] = PCNCSMatrix(NCSMatrix)->v[i]; } WhatIsSet = PCNCSMatrix(NCSMatrix)->WhatIsSet; } void CNCSMatrix::write ( RCFile f ) { int i,j; byte Version=1; f.WriteByte ( &Version ); f.WriteInt ( &serNum ); f.WriteInt ( &iGiven ); for (i=0;i<3;i++) { for (j=0;j<3;j++) f.WriteReal ( &(m[i][j]) ); f.WriteReal ( &(v[i]) ); } f.WriteWord ( &WhatIsSet ); } void CNCSMatrix::read ( RCFile f ) { int i,j; byte Version; f.ReadByte ( &Version ); f.ReadInt ( &serNum ); f.ReadInt ( &iGiven ); for (i=0;i<3;i++) { for (j=0;j<3;j++) f.ReadReal ( &(m[i][j]) ); f.ReadReal ( &(v[i]) ); } f.ReadWord ( &WhatIsSet ); } MakeStreamFunctions(CNCSMatrix) // ================ CTVect =================== CTVect::CTVect() : CContainerClass() { Init(); } CTVect::CTVect ( cpstr S ) : CContainerClass() { Init(); ConvertPDBASCII ( S ); } CTVect::CTVect ( RPCStream Object ) : CContainerClass(Object) { Init(); } CTVect::~CTVect() { if (comment) delete[] comment; } void CTVect::Init() { serNum = -1; t[0] = 0.0; t[1] = 0.0; t[2] = 0.0; comment = NULL; } void CTVect::PDBASCIIDump ( pstr S, int N ) { UNUSED_ARGUMENT(N); // makes the ASCII PDB TVECT line number N sprintf ( S,"TVECT %3i",serNum ); PadSpaces ( S,80 ); PutRealF ( &(S[10]),t[0],10,5 ); PutRealF ( &(S[20]),t[1],10,5 ); PutRealF ( &(S[30]),t[2],10,5 ); if (comment) strncpy ( &(S[40]),comment,IMin(30,strlen(comment)) ); } int CTVect::ConvertPDBASCII ( cpstr S ) { GetInteger ( serNum ,&(S[7]) ,3 ); GetReal ( t[0] ,&(S[10]),10 ); GetReal ( t[1] ,&(S[20]),10 ); GetReal ( t[2] ,&(S[30]),10 ); CreateCopy ( comment,&(S[40]) ); return 0; } void CTVect::MakeCIF ( PCMMCIFData CIF, int N ) { PCMMCIFLoop Loop; int RC; RC = CIF->AddLoop ( CIFCAT_DATABASE_PDB_TVECT,Loop ); if ((RC!=CIFRC_Ok) || (N==0)) { // the category was (re)created, provide tags Loop->AddLoopTag ( CIFTAG_ID ); Loop->AddLoopTag ( CIFTAG_VECTOR1 ); Loop->AddLoopTag ( CIFTAG_VECTOR2 ); Loop->AddLoopTag ( CIFTAG_VECTOR3 ); Loop->AddLoopTag ( CIFTAG_DETAILS ); } Loop->AddInteger ( serNum ); Loop->AddReal ( t[0] ); Loop->AddReal ( t[1] ); Loop->AddReal ( t[2] ); Loop->AddString ( comment ); } void CTVect::GetCIF ( PCMMCIFData CIF, int & Signal ) { PCMMCIFLoop Loop; Loop = CIF->GetLoop ( CIFCAT_DATABASE_PDB_TVECT ); if (!Loop) { Signal = -1; // signal to finish processing of this structure return; } if (Signal>=Loop->GetLoopLength()) { Signal = -1; return; } if (CIFGetInteger(serNum,Loop,CIFTAG_ID,Signal)) return; if (CIFGetReal(t[0],Loop,CIFTAG_VECTOR1,Signal)) return; if (CIFGetReal(t[1],Loop,CIFTAG_VECTOR2,Signal)) return; if (CIFGetReal(t[2],Loop,CIFTAG_VECTOR3,Signal)) return; Loop->GetString ( comment,CIFTAG_DETAILS,Signal,True ); Signal++; } void CTVect::Copy ( PCContainerClass TVect ) { int i; serNum = PCTVect(TVect)->serNum; for (i=0;i<3;i++) t[i] = PCTVect(TVect)->t[i]; CreateCopy ( comment,PCTVect(TVect)->comment ); } void CTVect::write ( RCFile f ) { int i; byte Version=1; f.WriteByte ( &Version ); f.WriteInt ( &serNum ); for (i=0;i<3;i++) f.WriteReal ( &(t[i]) ); f.CreateWrite ( comment ); } void CTVect::read ( RCFile f ) { int i; byte Version; f.ReadByte ( &Version ); f.ReadInt ( &serNum ); for (i=0;i<3;i++) f.ReadReal ( &(t[i]) ); f.CreateRead ( comment ); } MakeStreamFunctions(CTVect) // ===================== CMMDBCryst ======================= CMMDBCryst::CMMDBCryst() : CStream() { Init ( True ); } CMMDBCryst::CMMDBCryst ( RPCStream Object ) : CStream(Object) { Init ( True ); } void CMMDBCryst::Init ( Boolean fullInit ) { int i,j,k; WhatIsSet = 0; // nothing is set a = 1.0; b = 1.0; c = 1.0; alpha = 90.0; beta = 90.0; gamma = 90.0; strcpy ( spaceGroup ,"" ); strcpy ( spaceGroupFix,"" ); Z = 1; CellCheck = CCHK_NoCell; for (i=0;i<3;i++) { for (j=0;j<3;j++) { o[i][j] = 0.0; s[i][j] = 0.0; for (k=0;k<6;k++) RR[k][i][j] = 0.0; } o[i][i] = 1.0; s[i][i] = 1.0; t[i] = 0.0; u[i] = 0.0; for (k=0;k<6;k++) RR[k][i][i] = 1.0; } for (i=0;i<4;i++) { for (j=0;j<4;j++) { RO [i][j] = 0.0; RF [i][j] = 0.0; ROU[i][j] = 0.0; RFU[i][j] = 0.0; } RO [i][i] = 1.0; RF [i][i] = 1.0; ROU[i][i] = 1.0; RFU[i][i] = 1.0; } Vol = 0.0; VolChk = 0.0; VolErr = 0.0; as = 1.0; bs = 1.0; cs = 1.0; alphas = 90.0; betas = 90.0; gammas = 90.0; for (k=0;k<6;k++) AC[k] = 0.0; NCode = 0; if (fullInit) { syminfo_lib = NULL; ignoreScalei = False; // flag to ignore SCALEi cards processSG = True; // flag to process space group at file read fixSpaceGroup = True; // flag to fix space group at file read } } CMMDBCryst::~CMMDBCryst() { FreeMemory(); if (syminfo_lib) delete[] syminfo_lib; } void CMMDBCryst::FreeMemory() { NCSMatrix.FreeContainer(); TVect .FreeContainer(); SymOps .FreeMemory (); } void CMMDBCryst::Reset() { FreeMemory(); Init ( False ); } cpstr rhombohedral[] = { cpstr("R 3" ), cpstr("R 3" ), cpstr("R 3 2"), cpstr("R 3 2") }; cpstr short_mono[] = { cpstr("P 2" ), cpstr("P 21"), cpstr("C 2" ), cpstr("A 2" ), cpstr("B 2" ), cpstr("I 2" ) }; cpstr special[] = { cpstr("A1" ), cpstr("Hall: P 1 (-x,-1/2*y+1/2*z,1/2*y+1/2*z)" ), cpstr("C1211" ), cpstr("Hall: C 2y (x+1/4,y+1/4,z)" ), cpstr("C21" ), cpstr("Hall: C 2y (x+1/4,y+1/4,z)" ), cpstr("I1211" ), cpstr("Hall: C 2y (x+1/4,y+1/4,-x+z-1/4)" ), cpstr("I21" ), cpstr("Hall: C 2y (x+1/4,y+1/4,-x+z-1/4)" ), cpstr("P21212A"), cpstr("Hall: P 2 2ab (x+1/4,y+1/4,z)" ), cpstr("F422" ), cpstr("Hall: I 4 2 (1/2*x+1/2*y,-1/2*x+1/2*y,z)" ), cpstr("C4212" ), cpstr("Hall: P 4 2 (1/2*x+1/2*y-1/4,-1/2*x+1/2*y-1/4,z)") }; int CMMDBCryst::FixSpaceGroup() { // This function attempts to clean up the Brookhaven mess in space // group naming, by checking the space group symbol with cell // parameters. Returns: // // 0 - space group symbol is correct, spaceGroupFix receives // a copy of spaceGroup // 1 - space group symbol does not agree with cell parameters, // and fixed successfully. spaceGroupFix receives // the appropriate space group symbol // -1 - space group symbol does not agree with cell parameters, // however fix is not possible. spaceGroupFix receives // a copy of spaceGroup // -2 - any checks are not possible because cell parameters // are not found, spaceGroupFix receives a copy of // spaceGroup // realtype eps,m1,m2; SymGroup s; int i,k; char c; strcpy ( spaceGroupFix,spaceGroup ); if ((WhatIsSet & CSET_CellParams)!=CSET_CellParams) return -2; eps = 0.01; k = -1; for (i=0;(i<4) && (k<0);i++) if (!strcmp(spaceGroup,rhombohedral[i])) k = i; if (k>=0) { c = 'N'; if ((fabs(a-b)<=eps) && (fabs(alpha-90.0)<=eps) && (fabs(beta-90.0)<=eps) && (fabs(gamma-120.0)<=eps)) c = 'H'; else { m1 = (a+b+c)/3.0; m2 = (alpha+beta+gamma)/3.0; if ((fabs(a-m1)<=eps) && (fabs(b-m1)<=eps) && (fabs(c-m1)<=eps) && (fabs(alpha-m2)<=eps) && (fabs(beta-m2)<=eps) && (fabs(gamma-m2)<=eps)) c = 'R'; } if (c!=spaceGroup[0]) { if (c!='N') { spaceGroupFix[0] = c; return 1; } return -1; } return 0; } for (i=0;(i<6) && (k<0);i++) if (!strcmp(spaceGroup,short_mono[i])) k = i; if (k>=0) { if ((fabs(alpha-90.0)<=eps) && (fabs(gamma-90.0)<=eps)) { if (spaceGroup[0]=='B') return -1; sprintf ( spaceGroupFix,"%c 1 %s 1",spaceGroup[0], &(spaceGroup[2]) ); return 1; } if ((fabs(alpha-90.0)<=eps) && (fabs(beta-90.0)<=eps)) { if (spaceGroup[0]=='C') return -1; sprintf ( spaceGroupFix,"%c 1 1 %s",spaceGroup[0], &(spaceGroup[2]) ); return 1; } return -1; } i = 0; k = 0; while (spaceGroup[i]) { if (spaceGroup[i]!=' ') s[k++] = spaceGroup[i]; i++; } s[k] = char(0); k = -1; for (i=0;(i<16) && (k<0);i+=2) if (!strcmp(s,special[i])) k = i; if (k>=0) { strcpy ( spaceGroupFix,special[k+1] ); return 1; } return 0; } int CMMDBCryst::ConvertPDBString ( pstr PDBString ) { // Interprets the ASCII PDB line and fills the corresponding fields. // Returns zero if the line was converted, otherwise returns a // non-negative value of Error_XXXX. // PDBString must be not shorter than 81 characters. int RC; PCNCSMatrix ncsMatrix; PCTVect tVect; // pad input line with spaces, if necessary PadSpaces ( PDBString,80 ); if (!strncmp(PDBString,"CRYST",5)) { // Here we check for "CRYST" and not for "CRYST1" keyword. // As seems, people tend to not differentiating them. if (GetReal(a,&(PDBString[6]) ,9) && GetReal(b,&(PDBString[15]),9) && GetReal(c,&(PDBString[24]),9)) WhatIsSet |= CSET_CellParams1; if (GetReal(alpha,&(PDBString[33]),7) && GetReal(beta ,&(PDBString[40]),7) && GetReal(gamma,&(PDBString[47]),7)) WhatIsSet |= CSET_CellParams2; GetString ( spaceGroup,&(PDBString[55]),11 ); CutSpaces ( spaceGroup,SCUTKEY_BEGEND ); if (fixSpaceGroup) FixSpaceGroup(); else strcpy ( spaceGroupFix,spaceGroup ); if (spaceGroupFix[0] && processSG) { if (SymOps.SetGroup(spaceGroupFix,syminfo_lib)==SYMOP_Ok) WhatIsSet |= CSET_SpaceGroup; } if (GetInteger(Z,&(PDBString[66]),4)) WhatIsSet |= CSET_ZValue; WhatIsSet &= 0xFBFF; if ((a*b*c*alpha*beta*gamma==0.0) || ((a==1.0) && (b==1.0) && (c==1.0) && (alpha==90.0) && (beta==90.0) && (gamma==90.0) && (!strcmp(spaceGroup,"P 1")))) { WhatIsSet &= ~(CSET_CellParams1 | CSET_CellParams2 | CSET_SpaceGroup); WhatIsSet |= CSET_DummyCell; } } else if (!strncmp(PDBString,"ORIGX1",6)) { if (GetReal(o[0][0],&(PDBString[10]),10) && GetReal(o[0][1],&(PDBString[20]),10) && GetReal(o[0][2],&(PDBString[30]),10) && GetReal(t[0] ,&(PDBString[45]),10)) WhatIsSet |= CSET_OrigMatrix1; } else if (!strncmp(PDBString,"ORIGX2",6)) { if (GetReal(o[1][0],&(PDBString[10]),10) && GetReal(o[1][1],&(PDBString[20]),10) && GetReal(o[1][2],&(PDBString[30]),10) && GetReal(t[1] ,&(PDBString[45]),10)) WhatIsSet |= CSET_OrigMatrix2; } else if (!strncmp(PDBString,"ORIGX3",6)) { if (GetReal(o[2][0],&(PDBString[10]),10) && GetReal(o[2][1],&(PDBString[20]),10) && GetReal(o[2][2],&(PDBString[30]),10) && GetReal(t[2] ,&(PDBString[45]),10)) WhatIsSet |= CSET_OrigMatrix3; } else if (!strncmp(PDBString,"SCALE1",6)) { if (GetReal(s[0][0],&(PDBString[10]),10) && GetReal(s[0][1],&(PDBString[20]),10) && GetReal(s[0][2],&(PDBString[30]),10) && GetReal(u[0] ,&(PDBString[45]),10)) WhatIsSet |= CSET_ScaleMatrix1; WhatIsSet &= 0xFBFF; CellCheck |= CCHK_Unchecked; } else if (!strncmp(PDBString,"SCALE2",6)) { if (GetReal(s[1][0],&(PDBString[10]),10) && GetReal(s[1][1],&(PDBString[20]),10) && GetReal(s[1][2],&(PDBString[30]),10) && GetReal(u[1] ,&(PDBString[45]),10)) WhatIsSet |= CSET_ScaleMatrix2; WhatIsSet &= 0xFBFF; CellCheck |= CCHK_Unchecked; } else if (!strncmp(PDBString,"SCALE3",6)) { if (GetReal(s[2][0],&(PDBString[10]),10) && GetReal(s[2][1],&(PDBString[20]),10) && GetReal(s[2][2],&(PDBString[30]),10) && GetReal(u[2] ,&(PDBString[45]),10)) WhatIsSet |= CSET_ScaleMatrix3; WhatIsSet &= 0xFBFF; CellCheck |= CCHK_Unchecked; } else if (!strncmp(PDBString,"MTRIX",5)) { RC = NCSMatrix.AddMTRIXLine ( PDBString ); if (RC==Error_NCSM_WrongSerial) { ncsMatrix = new CNCSMatrix(); RC = ncsMatrix->ConvertPDBASCII ( PDBString ); if (RC==0) NCSMatrix.AddData ( ncsMatrix ); else delete ncsMatrix; } return RC; } else if (!strncmp(PDBString,"TVECT ",6)) { tVect = new CTVect(); RC = tVect->ConvertPDBASCII(PDBString); if (RC==0) TVect.AddData ( tVect ); else delete tVect; return RC; } else return Error_WrongSection; return 0; } void CMMDBCryst::PDBASCIIDump ( RCFile f ) { int i,j; char S[100]; if (WhatIsSet & (CSET_CrystCard | CSET_DummyCell)) { strcpy ( S,"CRYST1" ); PadSpaces ( S,80 ); if (WhatIsSet & CSET_CellParams1) { PutRealF ( &(S[6 ]),a,9,3 ); PutRealF ( &(S[15]),b,9,3 ); PutRealF ( &(S[24]),c,9,3 ); } if (WhatIsSet & CSET_CellParams2) { PutRealF ( &(S[33]),alpha,7,2 ); PutRealF ( &(S[40]),beta ,7,2 ); PutRealF ( &(S[47]),gamma,7,2 ); } if ((WhatIsSet & CSET_SpaceGroup) || (spaceGroup[0])) strncpy ( &(S[55]),spaceGroup,IMin(11,strlen(spaceGroup)) ); if (WhatIsSet & CSET_ZValue) PutInteger ( &(S[66]),Z,4 ); f.WriteLine ( S ); } if ((WhatIsSet & CSET_OrigMatrix)==CSET_OrigMatrix) for (i=0;i<3;i++) { sprintf ( S,"ORIGX%1i",i+1); PadSpaces ( S,80 ); for (j=0;j<3;j++) PutRealF ( &(S[10+j*10]),o[i][j],10,6 ); PutRealF ( &(S[45]),t[i],10,5 ); f.WriteLine ( S ); } if ((WhatIsSet & CSET_ScaleMatrix)==CSET_ScaleMatrix) for (i=0;i<3;i++) { sprintf ( S,"SCALE%1i",i+1); PadSpaces ( S,80 ); for (j=0;j<3;j++) PutRealF ( &(S[10+j*10]),s[i][j],10,6 ); PutRealF ( &(S[45]),u[i],10,5 ); f.WriteLine ( S ); } NCSMatrix.PDBASCIIDump ( f ); TVect .PDBASCIIDump ( f ); } int CMMDBCryst::GetCIF ( PCMMCIFData CIF ) { PCMMCIFStruct Struct; int RC; WhatIsSet = 0; Struct = CIF->GetStructure ( CIFCAT_CELL ); if (Struct) { RC = CIFGetReal ( a,Struct,CIFTAG_LENGTH_A ); if (!RC) RC = CIFGetReal ( b,Struct,CIFTAG_LENGTH_B ); if (!RC) RC = CIFGetReal ( c,Struct,CIFTAG_LENGTH_C ); if (RC==Error_UnrecognizedReal) return RC; if (!RC) WhatIsSet |= CSET_CellParams1; RC = CIFGetReal ( alpha,Struct,CIFTAG_ANGLE_ALPHA ); if (!RC) RC = CIFGetReal ( beta,Struct,CIFTAG_ANGLE_BETA ); if (!RC) RC = CIFGetReal ( gamma,Struct,CIFTAG_ANGLE_GAMMA ); if (RC==Error_UnrecognizedReal) return RC; if (!RC) WhatIsSet |= CSET_CellParams2; RC = CIFGetInteger ( Z,Struct,CIFTAG_Z_PDB ); if (RC==Error_UnrecognizedReal) return RC; if (!RC) WhatIsSet |= CSET_ZValue; } Struct = CIF->GetStructure ( CIFCAT_SYMMETRY ); if (Struct) { CIFGetString ( spaceGroup,Struct,CIFTAG_SPACE_GROUP_NAME_H_M, sizeof(spaceGroup),pstr("") ); CutSpaces ( spaceGroup,SCUTKEY_BEGEND ); if (fixSpaceGroup) FixSpaceGroup(); else strcpy ( spaceGroupFix,spaceGroup ); /* if (fixSpaceGroup) { if (!strcasecmp(spaceGroup,"P 21")) strcpy ( spaceGroup,"P 1 21 1" ); else if (!strcasecmp(spaceGroup,"C 2")) strcpy ( spaceGroup,"C 1 2 1" ); } */ if (spaceGroupFix[0] && processSG) { if (SymOps.SetGroup(spaceGroupFix,syminfo_lib)==SYMOP_Ok) WhatIsSet |= CSET_SpaceGroup; } } if ((a*b*c*alpha*beta*gamma==0.0) || ((a==1.0) && (b==1.0) && (c==1.0) && (alpha==90.0) && (beta==90.0) && (gamma==90.0) && (!strcmp(spaceGroup,"P 1")))) { WhatIsSet &= ~(CSET_CellParams1 | CSET_CellParams2 | CSET_SpaceGroup); WhatIsSet |= CSET_DummyCell; } Struct = CIF->GetStructure ( CIFCAT_DATABASE_PDB_MATRIX ); if (Struct) { RC = CIFGetReal ( o[0][0],Struct,CIFTAG_ORIGX11 ); if (!RC) RC = CIFGetReal ( o[0][1],Struct,CIFTAG_ORIGX12 ); if (!RC) RC = CIFGetReal ( o[0][2],Struct,CIFTAG_ORIGX13 ); if (!RC) RC = CIFGetReal ( o[1][0],Struct,CIFTAG_ORIGX21 ); if (!RC) RC = CIFGetReal ( o[1][1],Struct,CIFTAG_ORIGX22 ); if (!RC) RC = CIFGetReal ( o[1][2],Struct,CIFTAG_ORIGX23 ); if (!RC) RC = CIFGetReal ( o[2][0],Struct,CIFTAG_ORIGX31 ); if (!RC) RC = CIFGetReal ( o[2][1],Struct,CIFTAG_ORIGX32 ); if (!RC) RC = CIFGetReal ( o[2][2],Struct,CIFTAG_ORIGX33 ); if (!RC) RC = CIFGetReal ( t[0] ,Struct,CIFTAG_ORIGX_VECTOR1 ); if (!RC) RC = CIFGetReal ( t[1] ,Struct,CIFTAG_ORIGX_VECTOR2 ); if (!RC) RC = CIFGetReal ( t[2] ,Struct,CIFTAG_ORIGX_VECTOR3 ); if (RC) return RC; WhatIsSet |= CSET_OrigMatrix; } Struct = CIF->GetStructure ( CIFCAT_ATOM_SITES ); if (Struct) { RC = CIFGetReal ( s[0][0],Struct,CIFTAG_FRACT_TRANSF_MATRIX11 ); if (!RC) RC = CIFGetReal(s[0][1],Struct,CIFTAG_FRACT_TRANSF_MATRIX12); if (!RC) RC = CIFGetReal(s[0][2],Struct,CIFTAG_FRACT_TRANSF_MATRIX13); if (!RC) RC = CIFGetReal(s[1][0],Struct,CIFTAG_FRACT_TRANSF_MATRIX21); if (!RC) RC = CIFGetReal(s[1][1],Struct,CIFTAG_FRACT_TRANSF_MATRIX22); if (!RC) RC = CIFGetReal(s[1][2],Struct,CIFTAG_FRACT_TRANSF_MATRIX23); if (!RC) RC = CIFGetReal(s[2][0],Struct,CIFTAG_FRACT_TRANSF_MATRIX31); if (!RC) RC = CIFGetReal(s[2][1],Struct,CIFTAG_FRACT_TRANSF_MATRIX32); if (!RC) RC = CIFGetReal(s[2][2],Struct,CIFTAG_FRACT_TRANSF_MATRIX33); if (!RC) RC = CIFGetReal(u[0] ,Struct,CIFTAG_FRACT_TRANSF_VECTOR1 ); if (!RC) RC = CIFGetReal(u[1] ,Struct,CIFTAG_FRACT_TRANSF_VECTOR2 ); if (!RC) RC = CIFGetReal(u[2] ,Struct,CIFTAG_FRACT_TRANSF_VECTOR3 ); if (RC) return RC; WhatIsSet |= CSET_ScaleMatrix; } RC = NCSMatrix.GetCIF(CIF,ClassID_NCSMatrix); if (RC) return RC; RC = TVect.GetCIF(CIF,ClassID_TVect); return RC; } void CMMDBCryst::MakeCIF ( PCMMCIFData CIF ) { PCMMCIFStruct Struct; char S[200]; if (WhatIsSet & (CSET_CellParams1 | CSET_DummyCell)) { CIF->AddStructure ( CIFCAT_CELL,Struct ); Struct->PutReal ( a,CIFTAG_LENGTH_A,8 ); Struct->PutReal ( b,CIFTAG_LENGTH_B,8 ); Struct->PutReal ( c,CIFTAG_LENGTH_C,8 ); } if (WhatIsSet & (CSET_CellParams2 | CSET_DummyCell)) { CIF->AddStructure ( CIFCAT_CELL,Struct ); Struct->PutReal ( alpha,CIFTAG_ANGLE_ALPHA,8 ); Struct->PutReal ( beta ,CIFTAG_ANGLE_BETA, 8 ); Struct->PutReal ( gamma,CIFTAG_ANGLE_GAMMA,8 ); } if ((WhatIsSet & (CSET_SpaceGroup | CSET_DummyCell)) || (spaceGroup[0])) CIF->PutString ( strcpy_cs(S,spaceGroup),CIFCAT_SYMMETRY, CIFTAG_SPACE_GROUP_NAME_H_M ); if (WhatIsSet & (CSET_ZValue | CSET_DummyCell)) CIF->PutInteger ( Z,CIFCAT_CELL,CIFTAG_Z_PDB ); if ((WhatIsSet & CSET_OrigMatrix)==CSET_OrigMatrix) { CIF->AddStructure ( CIFCAT_DATABASE_PDB_MATRIX,Struct ); Struct->PutReal ( o[0][0],CIFTAG_ORIGX11 ,8 ); Struct->PutReal ( o[0][1],CIFTAG_ORIGX12 ,8 ); Struct->PutReal ( o[0][2],CIFTAG_ORIGX13 ,8 ); Struct->PutReal ( o[1][0],CIFTAG_ORIGX21 ,8 ); Struct->PutReal ( o[1][1],CIFTAG_ORIGX22 ,8 ); Struct->PutReal ( o[1][2],CIFTAG_ORIGX23 ,8 ); Struct->PutReal ( o[2][0],CIFTAG_ORIGX31 ,8 ); Struct->PutReal ( o[2][1],CIFTAG_ORIGX32 ,8 ); Struct->PutReal ( o[2][2],CIFTAG_ORIGX33 ,8 ); Struct->PutReal ( t[0] ,CIFTAG_ORIGX_VECTOR1,8 ); Struct->PutReal ( t[1] ,CIFTAG_ORIGX_VECTOR2,8 ); Struct->PutReal ( t[2] ,CIFTAG_ORIGX_VECTOR3,8 ); } if ((WhatIsSet & CSET_ScaleMatrix)==CSET_ScaleMatrix) { CIF->AddStructure ( CIFCAT_ATOM_SITES,Struct ); Struct->PutReal ( s[0][0],CIFTAG_FRACT_TRANSF_MATRIX11,8 ); Struct->PutReal ( s[0][1],CIFTAG_FRACT_TRANSF_MATRIX12,8 ); Struct->PutReal ( s[0][2],CIFTAG_FRACT_TRANSF_MATRIX13,8 ); Struct->PutReal ( s[1][0],CIFTAG_FRACT_TRANSF_MATRIX21,8 ); Struct->PutReal ( s[1][1],CIFTAG_FRACT_TRANSF_MATRIX22,8 ); Struct->PutReal ( s[1][2],CIFTAG_FRACT_TRANSF_MATRIX23,8 ); Struct->PutReal ( s[2][0],CIFTAG_FRACT_TRANSF_MATRIX31,8 ); Struct->PutReal ( s[2][1],CIFTAG_FRACT_TRANSF_MATRIX32,8 ); Struct->PutReal ( s[2][2],CIFTAG_FRACT_TRANSF_MATRIX33,8 ); Struct->PutReal ( u[0] ,CIFTAG_FRACT_TRANSF_VECTOR1 ,8 ); Struct->PutReal ( u[1] ,CIFTAG_FRACT_TRANSF_VECTOR2 ,8 ); Struct->PutReal ( u[2] ,CIFTAG_FRACT_TRANSF_VECTOR3 ,8 ); } NCSMatrix.MakeCIF ( CIF ); TVect .MakeCIF ( CIF ); } cpstr OrthCode[6] = { cpstr("A/X0, C*/Z0"), // (standard brookhaven) cpstr("B/X0, A*/Z0"), cpstr("C/X0, B*/Z0"), cpstr("HEX A+B/X0, C*/Z0"), cpstr("A*/X0, C/Z0 (rollett)"), cpstr("A/X0, B*/Y0") }; cpstr getOrthCodeName ( int NCode ) { if ((NCode>0) && (NCode<=6)) return OrthCode[NCode-1]; return cpstr("CUSTOM"); } void CMMDBCryst::CalcCoordTransforms() { realtype rChk1,rChk2,Fac; int i,j,k; WhatIsSet &= ~CSET_Transforms; // clear the flag if ((WhatIsSet & CSET_CellParams)==CSET_CellParams) { // The 'cryst1' card was supplied. Calculate // standard orthogonalizations. CalcOrthMatrices(); if (NCode<0) NCode = 0; for (i=0;i<3;i++) { for (j=0;j<3;j++) RO[i][j] = RR[NCode][i][j]; RO[i][3] = 0.0; RO[3][i] = 0.0; } RO[3][3] = 1.0; Mat4Inverse ( RO,RF ); WhatIsSet |= CSET_Transforms; if (ignoreScalei) CellCheck = CCHK_Ok; else if ((WhatIsSet & CSET_ScaleMatrix)==CSET_ScaleMatrix) { // All 'scalei' cards were supplied. Calculate // rotation and translation matrices and check // if they are in consistence with the cell. for (i=0;i<3;i++) { for (j=0;j<3;j++) RF[i][j] = s[i][j]; RF[i][3] = u[i]; RF[3][i] = 0.0; } RF[3][3] = 1.0; Mat4Inverse ( RF,RO ); // Find orthogonalisation type VolChk = RO[0][0]*(RO[1][1]*RO[2][2] - RO[1][2]*RO[2][1]) + RO[0][1]*(RO[1][2]*RO[2][0] - RO[1][0]*RO[2][2]) + RO[0][2]*(RO[1][0]*RO[2][1] - RO[1][1]*RO[2][0]); CellCheck = CCHK_Ok; if (Vol>0.0) { VolErr = fabs(VolChk-Vol)/Vol; if (VolErr>0.02) CellCheck |= CCHK_Error; else if (VolErr>0.1) CellCheck |= CCHK_Disagreement; } else CellCheck |= CCHK_NoCell; // try to find NCode NCode = -1; for (k=0;(k<6) && (NCode<0);k++) { NCode = k; for (i=0;i<3;i++) for (j=0;j<3;j++) { rChk1 = RO[i][j] + RR[k][i][j]; rChk2 = RO[i][j] - RR[k][i][j]; if (fabs(rChk1)>=0.1) { if (fabs(rChk2/rChk1)>0.01) NCode = -1; } } } // Correct inaccuracy of SCALEi input due to FORMAT, // replace RF,RO with RR[NCode][][] if possible. if (NCode>=0) { for (i=0;i<3;i++) for (j=0;j<3;j++) RO[i][j] = RR[NCode][i][j]; Mat4Inverse ( RO,RF ); } else CellCheck |= CCHK_NoOrthCode; if ((u[0]!=0.0) || (u[1]!=0.0) || (u[2]!=0.0)) CellCheck |= CCHK_Translations; } // Generate ROU and RFU for AnisoU stuff RFU[3][3] = 1.0; for (i=0;i<3;i++) { Fac = sqrt(RF[i][0]*RF[i][0] + RF[i][1]*RF[i][1] + RF[i][2]*RF[i][2]); RFU[i][0] = RF[i][0]/Fac; RFU[i][1] = RF[i][1]/Fac; RFU[i][2] = RF[i][2]/Fac; RFU[i][3] = 0.0; RFU[3][i] = 0.0; } RFU[3][3] = 1.0; Mat4Inverse ( RFU,ROU ); } else CellCheck |= CCHK_NoCell; } void CMMDBCryst::RWBROOKReadPrintout() { int i,j; if ((WhatIsSet & CSET_CellParams)==CSET_CellParams) { printf ( " MATRICES DERIVED FROM CRYST1" " CARD IN COORDINATE FILE\n\n\n" " RF " " RO\n\n" ); for (i=0;i<4;i++) { printf ( " " ); for (j=0;j<4;j++) printf ( "%8.3f",RF[i][j] ); printf ( " " ); for (j=0;j<4;j++) printf ( "%8.3f",RO[i][j] ); printf ( "\n" ); } printf ( "\n" ); } else printf ( "\n $WARNING: NO CRYST CARDS READ$\n" ); if ((WhatIsSet & CSET_ScaleMatrix)!=CSET_ScaleMatrix) printf ( "\n $WARNING: NO SCALE CARDS READ$\n" ); } void CMMDBCryst::CalcOrthMatrices() { // Calculates matrices for standard orthogonalizations // and the cell volume. // The matrices are stored in array RR realtype Conv,Alph,Bet,Gamm,Sum,V; realtype sinA,cosA,sinB,cosB,sinG,cosG; realtype sinAS,cosAS,sinBS,cosBS,sinGS,cosGS; int i,j,k; if ((WhatIsSet & CSET_CellParams)!=CSET_CellParams) return; Conv = Pi/180.0; Alph = alpha*Conv; Bet = beta *Conv; Gamm = gamma*Conv; Sum = (Alph+Bet+Gamm)*0.5; V = sqrt(sin(Sum-Alph)*sin(Sum-Bet)*sin(Sum-Gamm)*sin(Sum)); Vol = 2.0*a*b*c*V; // Precaution measure for erratic use of the library if ((fabs(Alph)<1.0e-6) || (fabs(Bet)<1.0e-6) || (fabs(Gamm)<1.0e-6)) { as = 0.0; bs = 0.0; cs = 0.0; alphas = 0.0; betas = 0.0; gammas = 0.0; for (k=0;k<6;k++) { AC[k] = 0.0; for (i=0;i<3;i++) { for (j=0;j<3;j++) RR[k][i][j] = 0.0; RR[k][i][i] = 1.0; } } return; } sinA = sin(Alph); cosA = cos(Alph); sinB = sin(Bet); cosB = cos(Bet); sinG = sin(Gamm); cosG = cos(Gamm); cosAS = (cosG*cosB-cosA) / (sinB*sinG); sinAS = sqrt(1.0-cosAS*cosAS); cosBS = (cosA*cosG-cosB) / (sinA*sinG); sinBS = sqrt(1.0-cosBS*cosBS); cosGS = (cosA*cosB-cosG) / (sinA*sinB); sinGS = sqrt(1.0-cosGS*cosGS); as = b*c*sinA/Vol; bs = c*a*sinB/Vol; cs = a*b*sinG/Vol; alphas = atan2(sinAS,cosAS)/Conv; betas = atan2(sinBS,cosBS)/Conv; gammas = atan2(sinGS,cosGS)/Conv; // ---- Set useful things for calculating dstar AC[0] = as*as; AC[1] = bs*bs; AC[2] = cs*cs; AC[3] = 2.0*bs*cs*cosAS; AC[4] = 2.0*cs*as*cosBS; AC[5] = 2.0*as*bs*cosGS; // ---- Zero matrices for (k=0;k<6;k++) for (i=0;i<3;i++) for (j=0;j<3;j++) RR[k][i][j] = 0.0; // ---- Calculate matrices // ---- XO along a Zo along c* RR[0][0][0] = a; RR[0][0][1] = b*cosG; RR[0][0][2] = c*cosB; RR[0][1][1] = b*sinG; RR[0][1][2] = -c*sinB*cosAS; RR[0][2][2] = c*sinB*sinAS; // ---- XO along b Zo along a* RR[1][0][0] = a*cosG; RR[1][0][1] = b; RR[1][0][2] = c*cosA; RR[1][1][0] = -a*sinG*cosBS; RR[1][1][2] = c*sinA; RR[1][2][0] = a*sinG*sinBS; // ---- XO along c Zo along b* RR[2][0][0] = a*cosB; RR[2][0][1] = b*cosA; RR[2][0][2] = c; RR[2][1][0] = a*sinB; RR[2][1][1] = -b*sinA*cosGS; RR[2][2][1] = b*sinA*sinGS; // ---- trigonal only - XO along a+b YO alon a-b Zo along c* RR[3][0][0] = a/2.0; RR[3][0][1] = a/2.0; RR[3][1][0] = -a*sinG; RR[3][1][1] = a*sinG; RR[3][2][2] = c; // ---- XO along a*, ZO along c RR[4][0][0] = a*sinB*sinGS; RR[4][1][0] = -a*sinB*cosGS; RR[4][1][1] = b*sinA; RR[4][2][0] = a*cosB; RR[4][2][1] = b*cosA; RR[4][2][2] = c; // ---- Grr*! to Gerard Bricogne - his setting for P1 in SKEW. // XO along a, Y0 along b* RR[5][0][0] = a; RR[5][0][1] = b*cosG; RR[5][0][2] = c*cosB; RR[5][1][1] = b*sinG*sinAS; RR[5][2][1] = -b*sinG*cosAS; RR[5][2][2] = c*sinB; } Boolean CMMDBCryst::areMatrices() { // returns True if the orthogonal-to-fractional and // fractional-to-orthogonal matrices are defined return (WhatIsSet & CSET_Transforms)!=0x0000; } Boolean CMMDBCryst::Frac2Orth ( realtype x, realtype y, realtype z, realtype & xx, realtype & yy, realtype & zz ) { if (areMatrices()) { xx = RO[0][0]*x + RO[0][1]*y + RO[0][2]*z + RO[0][3]; yy = RO[1][0]*x + RO[1][1]*y + RO[1][2]*z + RO[1][3]; zz = RO[2][0]*x + RO[2][1]*y + RO[2][2]*z + RO[2][3]; return True; } else { xx = x; yy = y; zz = z; return False; } } Boolean CMMDBCryst::Orth2Frac ( realtype x, realtype y, realtype z, realtype & xx, realtype & yy, realtype & zz ) { if (areMatrices()) { xx = RF[0][0]*x + RF[0][1]*y + RF[0][2]*z + RF[0][3]; yy = RF[1][0]*x + RF[1][1]*y + RF[1][2]*z + RF[1][3]; zz = RF[2][0]*x + RF[2][1]*y + RF[2][2]*z + RF[2][3]; return True; } else { xx = x; yy = y; zz = z; return False; } } Boolean CMMDBCryst::Frac2Orth ( mat44 & F, mat44 & T ) { mat44 A; if (areMatrices()) { Mat4Mult ( A,F,RF ); Mat4Mult ( T,RO,A ); return True; } else { Mat4Init ( T ); return False; } } Boolean CMMDBCryst::Orth2Frac ( mat44 & T, mat44 & F ) { mat44 A; if (areMatrices()) { Mat4Mult ( A,T,RO ); Mat4Mult ( F,RF,A ); return True; } else { Mat4Init ( F ); return False; } } int CMMDBCryst::GetNumberOfSymOps() { return SymOps.GetNofSymOps(); } pstr CMMDBCryst::GetSymOp ( int Nop ) { return SymOps.GetSymOp ( Nop ); } int CMMDBCryst::GetTMatrix ( mat44 & TMatrix, int Nop, int cellshift_a, int cellshift_b, int cellshift_c, PCSymOps symOpers ) { // // GetTMatrix(..) calculates and returns the coordinate transformation // matrix, which converts orthogonal coordinates according to the // symmetry operation Nop and places them into unit cell shifted by // cellshift_a a's, cellshift_b b's and cellshift_c c's. // // Return 0 means everything's fine, // 1 there's no symmetry operation Nop defined // 2 fractionalizing/orthogonalizing matrices were not // calculated // 3 cell parameters were not set up. // mat44 fm; int i,j,k; if (cellshift_a<=-MaxInt4) { k = GetFractMatrix ( fm,Nop,0,0,0,symOpers ); fm[0][3] = frac(fm[0][3]); fm[1][3] = frac(fm[1][3]); fm[2][3] = frac(fm[2][3]); } else k = GetFractMatrix ( fm,Nop,cellshift_a,cellshift_b,cellshift_c, symOpers ); if (k) { Mat4Init ( TMatrix ); return k; } // transformation back to orthogonal coordinates for (i=0;i<3;i++) { for (j=0;j<4;j++) { TMatrix[i][j] = 0.0; for (k=0;k<3;k++) TMatrix[i][j] += RO[i][k]*fm[k][j]; } TMatrix[i][3] += RO[i][3]; } TMatrix[3][0] = 0.0; TMatrix[3][1] = 0.0; TMatrix[3][2] = 0.0; TMatrix[3][3] = 1.0; return 0; } int CMMDBCryst::GetUCTMatrix ( mat44 & TMatrix, int Nop, realtype x, realtype y, realtype z, int cellshift_a, int cellshift_b, int cellshift_c, PCSymOps symOpers ) { // // GetUCTMatrix(..) calculates and returns the coordinate // transformation matrix, which converts orthogonal coordinates // according to the symmetry operation Nop. Translation part of // the matrix is being chosen such that point (x,y,z) has least // distance to the center of primary (333) unit cell, and then // it is shifted by cellshift_a a's, cellshift_b b's and // cellshift_c c's. // // Return 0 means everything's fine, // 1 there's no symmetry operation Nop defined // 2 fractionalizing/orthogonalizing matrices were not // calculated // 3 cell parameters were not set up. // mat44 fm,tm; vect3 ft; realtype x0,y0,z0, dx,dy,dz, d,d0; int i,j,k, ic,jc,kc; k = GetFractMatrix ( fm,Nop,0,0,0,symOpers ); if (k) { Mat4Init ( TMatrix ); return k; } fm[0][3] = frac(fm[0][3]) + cellshift_a; fm[1][3] = frac(fm[1][3]) + cellshift_b; fm[2][3] = frac(fm[2][3]) + cellshift_c; Frac2Orth ( cellshift_a+0.5,cellshift_b+0.5,cellshift_c+0.5, x0,y0,z0 ); // transformation back to orthogonal coordinates for (i=0;i<3;i++) for (j=0;j<3;j++) { tm[i][j] = 0.0; for (k=0;k<3;k++) tm[i][j] += RO[i][k]*fm[k][j]; } tm[3][0] = 0.0; tm[3][1] = 0.0; tm[3][2] = 0.0; tm[3][3] = 1.0; d0 = MaxReal; for (ic=-3;ic<3;ic++) for (jc=-3;jc<3;jc++) for (kc=-3;kc<3;kc++) { ft[0] = fm[0][3] + ic; ft[1] = fm[1][3] + jc; ft[2] = fm[2][3] + kc; for (i=0;i<3;i++) { tm[i][3] = 0.0; for (k=0;k<3;k++) tm[i][3] += RO[i][k]*ft[k]; tm[i][3] += RO[i][3]; } dx = tm[0][0]*x + tm[0][1]*y + tm[0][2]*z + tm[0][3] - x0; dy = tm[1][0]*x + tm[1][1]*y + tm[1][2]*z + tm[1][3] - y0; dz = tm[2][0]*x + tm[2][1]*y + tm[2][2]*z + tm[2][3] - z0; d = dx*dx + dy*dy + dz*dz; if (dGetTMatrix ( tm,Nop ); else k = SymOps.GetTMatrix ( tm,Nop ); if (!k) { if (!areMatrices()) k = 2; if (!isCellParameters()) k = 3; } else k = 1; if (k) { Mat4Init ( TMatrix ); return k; } // transformation to fractional coordinates + symmetry operation for (i=0;i<3;i++) { for (j=0;j<4;j++) { TMatrix[i][j] = 0.0; for (k=0;k<3;k++) TMatrix[i][j] += tm[i][k]*RF[k][j]; } TMatrix[i][3] += tm[i][3]; // symmetry operation shift } // cell shift TMatrix[0][3] += cellshift_a; TMatrix[1][3] += cellshift_b; TMatrix[2][3] += cellshift_c; TMatrix[3][0] = 0.0; TMatrix[3][1] = 0.0; TMatrix[3][2] = 0.0; TMatrix[3][3] = 1.0; return 0; } int CMMDBCryst::GetSymOpMatrix ( mat44 & TMatrix, int Nop ) { // // GetSymOpMatrix(..) returns the transformation matrix for // Nop-th symmetry operator in the space group // // Return 0 means everything's fine, // 1 there's no symmetry operation Nop defined // 2 fractionalizing/orthogonalizing matrices were not // calculated // 3 cell parameters were not set up. // return SymOps.GetTMatrix ( TMatrix,Nop ); } Boolean CMMDBCryst::Cryst2Orth ( rvector U ) { mat33 A,AT,Tmp,TmpMat; realtype BB; int i,j,k; if (areMatrices()) { Tmp[0][0] = U[0]; Tmp[1][1] = U[1]; Tmp[2][2] = U[2]; Tmp[0][1] = U[3]; Tmp[1][0] = U[3]; Tmp[0][2] = U[4]; Tmp[2][0] = U[4]; Tmp[1][2] = U[5]; Tmp[2][1] = U[5]; for (i=0;i<3;i++) for (j=0;j<3;j++) { A [j][i] = ROU[j][i]; AT[i][j] = ROU[j][i]; } // TmpMat = Tmp*AT for (i=0;i<3;i++) for (j=0;j<3;j++) { BB = 0.0; for (k=0;k<3;k++) BB += Tmp[i][k]*AT[k][j]; TmpMat[i][j] = BB; } // Tmp = A*TmpMat for (i=0;i<3;i++) for (j=0;j<3;j++) { BB = 0.0; for (k=0;k<3;k++) BB += A[i][k]*TmpMat[k][j]; Tmp[i][j] = BB; } U[0] = Tmp[0][0]; U[1] = Tmp[1][1]; U[2] = Tmp[2][2]; U[3] = Tmp[0][1]; U[4] = Tmp[0][2]; U[5] = Tmp[1][2]; return True; } return False; } Boolean CMMDBCryst::Orth2Cryst ( rvector U ) { mat33 A,AT,Tmp,TmpMat; realtype BB; int i,j,k; if (areMatrices()) { Tmp[0][0] = U[0]; Tmp[1][1] = U[1]; Tmp[2][2] = U[2]; Tmp[0][1] = U[3]; Tmp[1][0] = U[3]; Tmp[0][2] = U[4]; Tmp[2][0] = U[4]; Tmp[1][2] = U[5]; Tmp[2][1] = U[5]; for (i=0;i<3;i++) for (j=0;j<3;j++) { A [j][i] = RFU[j][i]; AT[i][j] = RFU[j][i]; } // TmpMat = Tmp*AT for (i=0;i<3;i++) for (j=0;j<3;j++) { BB = 0.0; for (k=0;k<3;k++) BB += Tmp[i][k]*AT[k][j]; TmpMat[i][j] = BB; } // Tmp = A*TmpMat for (i=0;i<3;i++) for (j=0;j<3;j++) { BB = 0.0; for (k=0;k<3;k++) BB += A[i][k]*TmpMat[k][j]; Tmp[i][j] = BB; } U[0] = Tmp[0][0]; U[1] = Tmp[1][1]; U[2] = Tmp[2][2]; U[3] = Tmp[0][1]; U[4] = Tmp[0][2]; U[5] = Tmp[1][2]; return True; } return False; } void CMMDBCryst::SetCell ( realtype cell_a, realtype cell_b, realtype cell_c, realtype cell_alpha, realtype cell_beta, realtype cell_gamma, int OrthCode ) { // this function should be used for changing the cell parameters int i,j; if ((cell_a>0.0) && (cell_b>0.0) && (cell_c>0.0) && (cell_alpha!=0.0) && (cell_beta!=0.0) && (cell_gamma!=0.0)) { if (OrthCode>0) NCode = OrthCode-1; else NCode = 0; a = cell_a; b = cell_b; c = cell_c; alpha = cell_alpha; beta = cell_beta; gamma = cell_gamma; WhatIsSet |= CSET_CellParams; // calculate matrices for (i=0;i<4;i++) { for (j=0;j<4;j++) { RO [i][j] = 0.0; RF [i][j] = 0.0; ROU[i][j] = 0.0; RFU[i][j] = 0.0; } RO [i][i] = 1.0; RF [i][i] = 1.0; ROU[i][i] = 1.0; RFU[i][i] = 1.0; } CalcCoordTransforms(); if (!(CellCheck & CCHK_NoOrthCode)) { for (i=0;i<3;i++) { for (j=0;j<3;j++) RO[i][j] = RR[NCode][i][j]; RO[i][3] = 0.0; RO[3][i] = 0.0; } RO[3][3] = 1.0; Mat4Inverse ( RO,RF ); } WhatIsSet |= CSET_Transforms; } else WhatIsSet &= ~(CSET_CellParams | CSET_Transforms); } void CMMDBCryst::SetSyminfoLib ( cpstr syminfoLib ) { CreateCopy ( syminfo_lib,syminfoLib ); } pstr CMMDBCryst::GetSyminfoLib() { return syminfo_lib; } int CMMDBCryst::SetSpaceGroup ( cpstr spGroup ) { // This function does not attempt to fix the space group int RC,l; RC = SYMOP_UnknownSpaceGroup; WhatIsSet &= ~CSET_SpaceGroup; if (spGroup) { if (spGroup[0]) { l = IMin ( strlen(spGroup),sizeof(spaceGroup)-1 ); strcpy_ncss ( spaceGroup,spGroup,l ); strcpy ( spaceGroupFix,spaceGroup ); if (spaceGroup[0]) { RC = SymOps.SetGroup ( spaceGroup,syminfo_lib ); // RC = SymOps.SetGroup ( spGroup,syminfo_lib ); // strncpy ( spaceGroup,spGroup,l ); // spaceGroup[l] = char(0); if (RC==SYMOP_Ok) WhatIsSet |= CSET_SpaceGroup; } } } return RC; } void CMMDBCryst::PutCell ( realtype cell_a, realtype cell_b, realtype cell_c, realtype cell_alpha, realtype cell_beta, realtype cell_gamma, int OrthCode ) { // this function should be used for setting the cell parameters int i,j; if ((cell_a!=0.0) || (OrthCode>0)) { a = cell_a; b = cell_b; c = cell_c; alpha = cell_alpha; beta = cell_beta; gamma = cell_gamma; WhatIsSet |= CSET_CellParams; } if (OrthCode>0) { // calculate matrices NCode = OrthCode-1; CalcOrthMatrices(); for (i=0;i<3;i++) { for (j=0;j<3;j++) RO[i][j] = RR[NCode][i][j]; RO[i][3] = 0.0; RO[3][i] = 0.0; } RO[3][3] = 1.0; Mat4Inverse ( RO,RF ); WhatIsSet |= CSET_Transforms; } else WhatIsSet &= ~CSET_Transforms; for (i=0;i<3;i++) { for (j=0;j<3;j++) s[i][j] = RF[i][j]; u[i] = RF[i][3]; } WhatIsSet |= CSET_ScaleMatrix; } Boolean CMMDBCryst::isScaleMatrix() { return ((WhatIsSet & CSET_ScaleMatrix)==CSET_ScaleMatrix); } Boolean CMMDBCryst::isCellParameters() { return ((WhatIsSet & CSET_CellParams)==CSET_CellParams); } Boolean CMMDBCryst::isNCSMatrix() { return (NCSMatrix.Length()>0); } int CMMDBCryst::GetNumberOfNCSMatrices() { return NCSMatrix.Length(); } int CMMDBCryst::GetNumberOfNCSMates() { // Returns the number of NCS mates not given in the file (iGiven==0) int i,l,iG; PCNCSMatrix NCSM; iG = 0; l = NCSMatrix.Length(); for (i=0;iiGiven) iG++; } } return iG; } Boolean CMMDBCryst::GetNCSMatrix ( int NCSMatrixNo, mat33 & ncs_m, vect3 & ncs_v ) { int i,j; PCNCSMatrix NCSM; NCSM = PCNCSMatrix(NCSMatrix.GetContainerClass(NCSMatrixNo)); if (NCSM) { for (i=0;i<3;i++) { for (j=0;j<3;j++) ncs_m[i][j] = NCSM->m[i][j]; ncs_v[i] = NCSM->v[i]; } return True; } return False; } Boolean CMMDBCryst::GetNCSMatrix ( int NCSMatrixNo, mat44 & ncs_m, int & iGiven ) { int i,j; PCNCSMatrix NCSM; NCSM = PCNCSMatrix(NCSMatrix.GetContainerClass(NCSMatrixNo)); if (NCSM) { for (i=0;i<3;i++) { for (j=0;j<3;j++) ncs_m[i][j] = NCSM->m[i][j]; ncs_m[i][3] = NCSM->v[i]; } ncs_m[3][0] = 0.0; ncs_m[3][1] = 0.0; ncs_m[3][2] = 0.0; ncs_m[3][3] = 1.0; iGiven = NCSM->iGiven; return True; } else { for (i=0;i<4;i++) { for (j=0;j<4;j++) ncs_m[i][j] = 0.0; ncs_m[i][i] = 1.0; } return False; } } int CMMDBCryst::AddNCSMatrix ( mat33 & ncs_m, vect3 & ncs_v, int iGiven ) { PCNCSMatrix ncsMatrix; ncsMatrix = new CNCSMatrix(); ncsMatrix->SetNCSMatrix ( NCSMatrix.Length()+1,ncs_m,ncs_v, iGiven ); NCSMatrix.AddData ( ncsMatrix ); return ncsMatrix->serNum; } void CMMDBCryst::GetRCell ( realtype & cell_as, realtype & cell_bs, realtype & cell_cs, realtype & cell_alphas, realtype & cell_betas, realtype & cell_gammas, realtype & vols ) { cell_as = as; cell_bs = bs; cell_cs = cs; cell_alphas = alphas; cell_betas = betas; cell_gammas = gammas; if (Vol!=0.0) vols = 1.0/Vol; else vols = 0.0; } void CMMDBCryst::GetCell ( realtype & cell_a, realtype & cell_b, realtype & cell_c, realtype & cell_alpha, realtype & cell_beta, realtype & cell_gamma, realtype & vol ) { if (WhatIsSet & CSET_CellParams) { cell_a = a; cell_b = b; cell_c = c; cell_alpha = alpha; cell_beta = beta; cell_gamma = gamma; vol = Vol; } else { cell_a = 0.0; cell_b = 0.0; cell_c = 0.0; cell_alpha = 0.0; cell_beta = 0.0; cell_gamma = 0.0; vol = 0.0; } } pstr CMMDBCryst::GetSpaceGroup() { if (WhatIsSet & CSET_SpaceGroup) return spaceGroup; else return NULL; } pstr CMMDBCryst::GetSpaceGroupFix() { if (WhatIsSet & CSET_SpaceGroup) return spaceGroupFix; else return NULL; } void CMMDBCryst::Copy ( PCMMDBCryst Cryst ) { int i,j,k; if (Cryst) { a = Cryst->a; b = Cryst->b; c = Cryst->c; alpha = Cryst->alpha; beta = Cryst->beta; gamma = Cryst->gamma; for (i=0;i<4;i++) for (j=0;j<4;j++) { RO [i][j] = Cryst->RO [i][j]; RF [i][j] = Cryst->RF [i][j]; ROU[i][j] = Cryst->ROU[i][j]; RFU[i][j] = Cryst->RFU[i][j]; } for (i=0;i<3;i++) { for (j=0;j<3;j++) { o[i][j] = Cryst->o[i][j]; s[i][j] = Cryst->s[i][j]; for (k=0;k<6;k++) RR[k][i][j] = Cryst->RR[k][i][j]; } t[i] = Cryst->t[i]; u[i] = Cryst->u[i]; } Vol = Cryst->Vol; NCode = Cryst->NCode; Z = Cryst->Z; CellCheck = Cryst->CellCheck; WhatIsSet = Cryst->WhatIsSet; strcpy ( spaceGroup ,Cryst->spaceGroup ); strcpy ( spaceGroupFix,Cryst->spaceGroupFix ); NCSMatrix.Copy ( &(Cryst->NCSMatrix) ); TVect .Copy ( &(Cryst->TVect) ); SymOps .Copy ( &(Cryst->SymOps) ); as = Cryst->as; bs = Cryst->bs; cs = Cryst->cs; alphas = Cryst->alphas; betas = Cryst->betas; gammas = Cryst->betas; VolChk = Cryst->VolChk; VolErr = Cryst->VolErr; for (k=0;k<6;k++) AC[k] = Cryst->AC[k]; } else { NCSMatrix.FreeContainer(); TVect .FreeContainer(); WhatIsSet = 0; } } void CMMDBCryst::write ( RCFile f ) { int i,j,k; byte Version=3; f.WriteByte ( &Version ); f.WriteWord ( &WhatIsSet ); f.WriteReal ( &a ); f.WriteReal ( &b ); f.WriteReal ( &c ); f.WriteReal ( &alpha ); f.WriteReal ( &beta ); f.WriteReal ( &gamma ); f.WriteWord ( &CellCheck ); f.WriteBool ( &ignoreScalei ); for (i=0;i<4;i++) for (j=0;j<4;j++) { f.WriteReal ( &(RO [i][j]) ); f.WriteReal ( &(RF [i][j]) ); f.WriteReal ( &(ROU[i][j]) ); f.WriteReal ( &(RFU[i][j]) ); } for (i=0;i<3;i++) { for (j=0;j<3;j++) { f.WriteReal ( &(o[i][j]) ); f.WriteReal ( &(s[i][j]) ); for (k=0;k<6;k++) f.WriteReal ( &(RR[k][i][j]) ); } f.WriteReal ( &(t[i]) ); f.WriteReal ( &(u[i]) ); } f.WriteReal ( &Vol ); f.WriteReal ( &VolChk ); f.WriteReal ( &VolErr ); f.WriteInt ( &NCode ); f.WriteInt ( &Z ); f.WriteTerLine ( spaceGroup ,False ); f.WriteTerLine ( spaceGroupFix,False ); for (i=0;i<6;i++) f.WriteReal ( &(AC[6]) ); f.WriteReal ( &as ); f.WriteReal ( &bs ); f.WriteReal ( &cs ); f.WriteReal ( &alphas ); f.WriteReal ( &betas ); f.WriteReal ( &gammas ); NCSMatrix.write ( f ); TVect .write ( f ); SymOps .write ( f ); } void CMMDBCryst::read ( RCFile f ) { int i,j,k; byte Version; f.ReadByte ( &Version ); f.ReadWord ( &WhatIsSet ); f.ReadReal ( &a ); f.ReadReal ( &b ); f.ReadReal ( &c ); f.ReadReal ( &alpha ); f.ReadReal ( &beta ); f.ReadReal ( &gamma ); f.ReadWord ( &CellCheck ); if (Version>2) f.ReadBool ( &ignoreScalei ); else ignoreScalei = False; for (i=0;i<4;i++) for (j=0;j<4;j++) { f.ReadReal ( &(RO [i][j]) ); f.ReadReal ( &(RF [i][j]) ); f.ReadReal ( &(ROU[i][j]) ); f.ReadReal ( &(RFU[i][j]) ); } for (i=0;i<3;i++) { for (j=0;j<3;j++) { f.ReadReal ( &(o[i][j]) ); f.ReadReal ( &(s[i][j]) ); for (k=0;k<6;k++) f.ReadReal ( &(RR[k][i][j]) ); } f.ReadReal ( &(t[i]) ); f.ReadReal ( &(u[i]) ); } f.ReadReal ( &Vol ); f.ReadReal ( &VolChk ); f.ReadReal ( &VolErr ); f.ReadInt ( &NCode ); f.ReadInt ( &Z ); f.ReadTerLine ( spaceGroup,False ); if (Version>1) f.ReadTerLine ( spaceGroupFix,False ); else strcpy ( spaceGroupFix,spaceGroup ); for (i=0;i<6;i++) f.ReadReal ( &(AC[6]) ); f.ReadReal ( &as ); f.ReadReal ( &bs ); f.ReadReal ( &cs ); f.ReadReal ( &alphas ); f.ReadReal ( &betas ); f.ReadReal ( &gammas ); NCSMatrix.read ( f ); TVect .read ( f ); SymOps .read ( f ); } MakeStreamFunctions(CMMDBCryst) // =================================================================== void TestCryst() { // reads from 'in.cryst', writes into // 'out.cryst' and 'abin.cryst' CFile f; char S[81]; PCMMDBCryst Cryst; Cryst = new CMMDBCryst(); f.assign ( pstr("in.cryst"),True ); if (f.reset()) { while (!f.FileEnd()) { f.ReadLine ( S,sizeof(S) ); Cryst->ConvertPDBString ( S ); } f.shut(); } else { printf ( " Can't open input file 'in.chain' \n" ); delete Cryst; return; } f.assign ( pstr("out.cryst"),True ); if (f.rewrite()) { Cryst->PDBASCIIDump ( f ); f.shut(); } else { printf ( " Can't open output file 'out.cryst' \n" ); delete Cryst; return; } f.assign ( pstr("mmdb.cryst.bin"),False ); if (f.rewrite()) { Cryst->write ( f ); f.shut(); } else { printf ( " Can't open binary cryst file for writing.\n" ); delete Cryst; return; } delete Cryst; printf ( " Cryst deleted.\n" ); Cryst = new CMMDBCryst(); if (f.reset()) { Cryst->read ( f ); f.shut(); } else { printf ( " Can't open binary cryst file for reading.\n" ); delete Cryst; return; } f.assign ( pstr("abin.cryst"),True ); if (f.rewrite()) { Cryst->PDBASCIIDump ( f ); f.shut(); } else printf ( " Can't open output file 'abin.cryst' \n" ); delete Cryst; } mmdb-1.25.5/mmdb/math_.cpp0000775000175000017500000001072311736610510012167 00000000000000// $Id: math_.cpp,v 1.20 2012/01/26 17:52:19 ekr Exp $ // ================================================================= // // CCP4 Coordinate Library: support of coordinate-related // functionality in protein crystallography applications. // // Copyright (C) Eugene Krissinel 2000-2008. // // This library is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // // ================================================================= // // 10.04.03 <-- Date of Last Modification. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ----------------------------------------------------------------- // // **** Module : Math_ // ~~~~~~~~~ // **** Functions : GetTorsion // ~~~~~~~~~~~ GetAngle // // (C) E. Krissinel 2000-2008 // // ================================================================= // #ifndef __MATH_H #include #endif #ifndef __Math__ #include "math_.h" #endif // ------------------------------------------------------------------ realtype GetTorsion ( rvector U, rvector W, rvector V ) { // U W V // o<----o----->o----->o // realtype A[3],B[3],C[3],Wmag,S,T; A[0] = U[1]*W[2] - W[1]*U[2]; A[1] = U[2]*W[0] - W[2]*U[0]; A[2] = U[0]*W[1] - W[0]*U[1]; B[0] = V[1]*W[2] - W[1]*V[2]; B[1] = V[2]*W[0] - W[2]*V[0]; B[2] = V[0]*W[1] - W[0]*V[1]; C[0] = A[1]*B[2] - B[1]*A[2]; C[1] = A[2]*B[0] - B[2]*A[0]; C[2] = A[0]*B[1] - B[0]*A[1]; Wmag = sqrt(W[0]*W[0]+W[1]*W[1]+W[2]*W[2]); S = C[0]*W[0] + C[1]*W[1] + C[2]*W[2]; T = A[0]*B[0] + A[1]*B[1] + A[2]*B[2]; T *= Wmag; if ((S==0.0) && (T==0.0)) return NO_TORSION; else return atan2(S,T); } realtype GetAngle ( rvector v1, rvector v2 ) { realtype l1,l2; l1 = v1[0]*v1[0] + v1[1]*v1[1] + v1[2]*v1[2]; if (l1==0.0) l1 = 1.0; l2 = v2[0]*v2[0] + v2[1]*v2[1] + v2[2]*v2[2]; if (l2==0.0) l2 = 1.0; return acos((v1[0]*v2[0]+v1[1]*v2[1]+v1[2]*v2[2])/sqrt(l1*l2)); } #define nCombMax 500 realtype Combinations ( int n, int m ) { // 0<=n<=nCombMax, 0<=m<=n realtype P[nCombMax+1]; int i,j; if ((m<0) || (m>n)) return 0.0; if ((m==0) || (m==n)) return 1.0; if ((m==1) || (m==n-1)) return realtype(n); P[0] = 1.0; P[1] = 3.0; P[2] = 3.0; P[3] = 1.0; for (i=4;i<=n;i++) { P[i] = 1.0; for (j=i-1;j>0;j--) P[j] += P[j-1]; } return P[m]; } realtype log1mx ( realtype x ) { // Calculates precisely log(1-x) for x<1, including // very small x realtype z,z1,z2,n; if (x>=1.0-10.0*MachEps) z = -MaxReal; else if (fabs(x)>1.0e-8) z = log(1.0-x); else { z1 = x; z = 0.0; n = 1.0; do { z2 = z; z -= z1/n; z1 *= x; n += 1.0; } while (z!=z2); } return z; } realtype expc ( realtype x ) { // Calculates precisely 1 - exp(x) for any x including // very small values realtype z,z1,z2,n; if (x>LnMaxReal) z = -MaxReal; else if (x<-LnMaxReal) z = 1.0; else if (fabs(x)>1.0e-8) z = 1.0 - Exp(x); else { z1 = x; z = x; n = 1.0; do { z2 = z; n += 1.0; z1 *= x/n; z += z1; } while (z!=z2); z = -z; } return z; } realtype expc1mx ( realtype x, realtype y ) { // Calculates precisely 1-(1-x)**y including very small x and // very large y realtype z,z1,z2,n,s; // Calculate (1-x)**y as exp(y*log(1-x)). Get log(1-x) first: if (x>1.0e-8) z = log(1.0-x); else { z1 = x; z = 0.0; n = 1.0; do { z2 = z; z -= z1/n; z1 *= x; n += 1.0; } while (z!=z2); } // Now calculate 1 - exp(y*log(1-x)) : z *= y; if (fabs(z)>1.0e-8) s = 1.0 - exp(z); else { z1 = z; s = z; n = 1.0; do { z2 = s; n += 1.0; z1 *= z/n; s += z1; } while (s!=z2); s = -s; } return s; } mmdb-1.25.5/mmdb/mmdb_uddata.cpp0000775000175000017500000003060311736610510013337 00000000000000// $Id: mmdb_uddata.cpp,v 1.19 2012/01/26 17:52:21 ekr Exp $ // ================================================================= // // CCP4 Coordinate Library: support of coordinate-related // functionality in protein crystallography applications. // // Copyright (C) Eugene Krissinel 2000-2008. // // This library is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // // ================================================================= // // 08.07.08 <-- Date of Last Modification. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ----------------------------------------------------------------- // // **** Module : MMDBF_UDData // ~~~~~~~~~ // **** Project : MacroMolecular Data Base (MMDB) // ~~~~~~~~~ // // **** Classes : CUDData ( user-defined data ) // ~~~~~~~~~ // // (C) E. Krissinel 2000-2008 // // ================================================================= // #ifndef __STRING_H #include #endif #ifndef __MMDB_UDData__ #include "mmdb_uddata.h" #endif // ======================== CUDRegister ========================== #define nUDRTypes 5 CUDRegister::CUDRegister() : CStream() { InitUDRegister(); } CUDRegister::CUDRegister ( RPCStream Object ) : CStream(Object) { InitUDRegister(); } CUDRegister::~CUDRegister() { FreeUDRegister(); } void CUDRegister::InitUDRegister() { int i; for (i=0;i=0) && (udr_type=0) && (udr_type=0) && (udr_type=0) && (udr_type0) { IUDRegister[j] = new pstr[nIUDR[j]]; for (i=0;i0) { RUDRegister[j] = new pstr[nRUDR[j]]; for (i=0;i0) { SUDRegister[j] = new pstr[nSUDR[j]]; for (i=0;i> 8); SUData[0][1] = byte((newN & 0x00FF0000) >> 16); SUData[0][0] = byte((newN & 0xFF000000) >> 24); } int CUDData::putUDData ( int UDDhandle, int iudd ) { ivector IUD; int i,l,udh; udh = UDDhandle & UDRF_MASK; if (udh<1) return UDDATA_WrongHandle; l = getNofIUData(); if (udh>l) { GetVectorMemory ( IUD,udh+1,0 ); IUD[0] = udh; for (i=1;i<=l;i++) IUD[i] = IUData[i]; for (i=l+1;il) { GetVectorMemory ( RUD,udh+1,0 ); RUD[0] = udh; for (i=1;i<=l;i++) RUD[i] = RUData[i]; for (i=l+1;il) { if (l>0) { GetVectorMemory ( SUD,udh+1,0 ); for (i=0;i<=l;i++) SUD[i] = SUData[i]; for (i=l+1;i<=udh;i++) SUD[i] = NULL; FreeVectorMemory ( SUData,0 ); SUData = SUD; } else { GetVectorMemory ( SUData,udh+1,0 ); SUData[0] = new char[4]; for (i=1;i<=udh;i++) SUData[i] = NULL; } setNofSUData ( udh ); } CreateCopy ( SUData[udh],sudd ); return UDDATA_Ok; } int CUDData::getUDData ( int UDDhandle, int & iudd ) { int l,udh; iudd = 0; udh = UDDhandle & UDRF_MASK; if (udh<1) return UDDATA_WrongHandle; l = getNofIUData(); if (udh>l) return UDDATA_NoData; iudd = IUData[udh]; if (iudd==MinInt4) return UDDATA_NoData; return UDDATA_Ok; } int CUDData::getUDData ( int UDDhandle, realtype & rudd ) { int l,udh; rudd = 0.0; udh = UDDhandle & UDRF_MASK; if (udh<1) return UDDATA_WrongHandle; l = getNofRUData(); if (udh>l) return UDDATA_NoData; rudd = RUData[udh]; if (rudd==-MaxReal) return UDDATA_NoData; return UDDATA_Ok; } int CUDData::getUDData ( int UDDhandle, pstr sudd, int maxLen ) { int l,udh; sudd[0] = char(0); udh = UDDhandle & UDRF_MASK; if (udh<1) return UDDATA_WrongHandle; l = getNofSUData(); if (udh>l) return UDDATA_NoData; if (!SUData[udh]) return UDDATA_NoData; strcpy_n0 ( sudd,SUData[udh],maxLen-1 ); return UDDATA_Ok; } pstr CUDData::getUDData ( int UDDhandle, int * retcode ) { int l,udh; udh = UDDhandle & UDRF_MASK; if (udh<1) { if (retcode) *retcode = UDDATA_WrongHandle; return NULL; } l = getNofSUData(); if (udh>l) { if (retcode) *retcode = UDDATA_NoData; return NULL; } if (!SUData[udh]) { if (retcode) *retcode = UDDATA_NoData; return NULL; } if (retcode) *retcode = UDDATA_Ok; return SUData[udh]; } int CUDData::getUDData ( int UDDhandle, pstr & sudd ) { int l,udh; udh = UDDhandle & UDRF_MASK; if (udh<1) { if (sudd) { delete[] sudd; sudd = NULL; } return UDDATA_WrongHandle; } l = getNofSUData(); if (udh>l) { if (sudd) { delete[] sudd; sudd = NULL; } return UDDATA_NoData; } if (!SUData[udh]) { if (sudd) { delete[] sudd; sudd = NULL; } return UDDATA_NoData; } CreateCopy ( sudd,SUData[udh] ); return UDDATA_Ok; } void CUDData::write ( RCFile f ) { int i,l; byte Version=1; f.WriteByte ( &Version ); CMask::write ( f ); if (IUData) l = IUData[0]; else l = -1; f.WriteVector ( IUData,l+1,0 ); if (RUData) l = mround(RUData[0]); else l = -1; f.WriteVector ( RUData,l+1,0 ); l = getNofSUData(); f.WriteInt ( &l ); for (i=1;i<=l;i++) f.CreateWrite ( SUData[i] ); } void CUDData::read ( RCFile f ) { int i,l; byte Version; f.ReadByte ( &Version ); FreeUDDMemory(); CMask::read ( f ); f.CreateReadVector ( IUData,0 ); f.CreateReadVector ( RUData,0 ); f.ReadInt ( &l ); if (l>0) { SUData = new pstr[l+1]; SUData[0] = new char[4]; setNofSUData ( l ); for (i=1;i<=l;i++) { SUData[i] = NULL; f.CreateRead ( SUData[i] ); } } } MakeStreamFunctions(CUDData) mmdb-1.25.5/mmdb/mmdb_model.cpp0000775000175000017500000042523012106546753013212 00000000000000// $Id: mmdb_model.cpp,v 1.27 2012/01/26 17:52:20 ekr Exp $ // ================================================================= // // CCP4 Coordinate Library: support of coordinate-related // functionality in protein crystallography applications. // // Copyright (C) Eugene Krissinel 2000-2008. // // This library is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // // ================================================================= // // 30.04.10 <-- Date of Last Modification. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ----------------------------------------------------------------- // // **** Module : MMDB_Model // ~~~~~~~~~ // **** Project : MacroMolecular Data Base (MMDB) // ~~~~~~~~~ // **** Classes : CHetCompound ( description of het compounds ) // ~~~~~~~~~ CHetCompounds ( HETNAM, HETSYN, FORMULA records ) // CSSContainer ( container for helixes and turns ) // CHelix ( helix info ) // CStrand ( strand info ) // CSheet ( sheet info ) // CSheets ( container for sheets ) // CTurn ( turn info ) // CLinkContainer ( container for link data ) // CLink ( link data ) // CLinkRContainer ( container for refmac link ) // CLinkR ( link data ) // CCisPepContainer ( container for CisPep data ) // CCisPep ( CisPep data ) // CModel ( PDB model ) // // Copyright (C) E. Krissinel 2000-2008 // // ================================================================= // #ifndef __STRING_H #include #endif #ifndef __STDLIB_H #include #endif #ifndef __MMDB_Model__ #include "mmdb_model.h" #endif #ifndef __MMDB_Manager__ #include "mmdb_manager.h" #endif #ifndef __MMDB_CIFDefs__ #include "mmdb_cifdefs.h" #endif // =================== CHetCompound ========================= CHetCompound::CHetCompound ( cpstr HetName ) : CStream() { InitHetCompound ( HetName ); } CHetCompound::CHetCompound ( RPCStream Object ) : CStream(Object) { InitHetCompound ( pstr("---") ); } CHetCompound::~CHetCompound() { FreeMemory(); } void CHetCompound::InitHetCompound ( cpstr HetName ) { strcpy_n0 ( hetID,HetName,sizeof(ResName) ); comment = NULL; nSynonyms = 0; hetSynonym = NULL; compNum = MinInt4; wc = ' '; Formula = NULL; } void CHetCompound::FreeMemory() { int i; if (comment) { delete[] comment; comment = NULL; } if (hetSynonym) { for (i=0;i53) { i = 0; while (p1[i] && (i<53) && (p1[i]!=' ')) i++; p2 = &(p1[i]); c = *p2; *p2 = char(0); } if (*p1) { strcat ( S,p1 ); PadSpaces ( S,80 ); f.WriteLine ( S ); } else N--; if (p2) { *p2 = c; if (c) p1 = p2+1; else p2 = NULL; } } while (p2); } void CHetCompound::HETSYN_PDBDump ( RCFile f ) { char S[100]; pstr p; char c; int N,k,i,l; if (!hetSynonym) return; N = 0; k = 0; p = &(hetSynonym[0][0]); do { N++; if (N==1) sprintf ( S,"HETSYN %3s " ,hetID ); else sprintf ( S,"HETSYN %2i %3s ",N,hetID ); i = 0; do { l = strlen(p)+2; if (i+l<54) { strcat ( S,p ); if (k51) { i--; while ((i>0) && (p[i]!=' ')) i--; } if (i<2) i = 51; // no spaces! c = p[i]; p[i] = char(0); strcat ( S,p ); p[i] = c; p = &(p[i]); while (*p==' ') p++; } i = 60; // break loop } } while (i<54); PadSpaces ( S,80 ); f.WriteLine ( S ); } while (kMinInt4) { if (N==1) sprintf ( S,"FORMUL %2i %3s " ,compNum,hetID ); else sprintf ( S,"FORMUL %2i %3s %2i ",compNum,hetID,N ); } else { if (N==1) sprintf ( S,"FORMUL %3s " ,hetID ); else sprintf ( S,"FORMUL %3s %2i ",hetID,N ); } S[18] = wc; p2 = strchr(p1,'\n'); if (p2) { c = *p2; *p2 = char(0); } else if (strlen(p1)>50) { while (*p1==' ') p1++; i = 0; while (p1[i] && (i<50) && (p1[i]!=' ')) i++; p2 = &(p1[i]); c = *p2; *p2 = char(0); } strcat ( S,p1 ); if (p2) { *p2 = c; p1 = p2+1; } PadSpaces ( S,80 ); f.WriteLine ( S ); } while (p2); } void CHetCompound::FormComString ( pstr & F ) { pstr p; int i; if (F) { delete[] F; F = NULL; } if (comment) { CreateCopy ( F,comment ); i = 0; p = comment; while (*p) { p++; if (*p=='\n') i = 0; else i++; if (i>68) { F[i] = char(0); CreateConcat ( F,pstr("\n"),p ); i = 0; } } } } void CHetCompound::FormSynString ( pstr & F ) { pstr p; char c; int i,k,l; if (F) { delete[] F; F = NULL; } if (hetSynonym) { CreateCopy ( F,pstr(" ") ); k = 0; p = &(hetSynonym[0][0]); do { l = strlen(p)+2; if (l<=60) { if (k60) { i--; while ((i>0) && (p[i]!=' ')) i--; } if (i<2) i = 60; // no spaces! c = p[i]; p[i] = char(0); CreateConcat ( F,p,pstr("\n ") ); p[i] = c; p = &(p[i]); while (*p==' ') p++; } } while (k68) { F[i] = char(0); CreateConcat ( F,pstr("\n"),p ); i = 0; } } } } void CHetCompound::Copy ( PCHetCompound HetCompound ) { int i; FreeMemory (); strcpy ( hetID ,HetCompound->hetID ); CreateCopy ( comment,HetCompound->comment ); nSynonyms = HetCompound->nSynonyms; if (nSynonyms>0) { hetSynonym = new pstr[nSynonyms]; for (i=0;ihetSynonym[i] ); } } compNum = HetCompound->compNum; wc = HetCompound->wc; CreateCopy ( Formula,HetCompound->Formula ); } void CHetCompound::write ( RCFile f ) { int i; byte Version=1; f.WriteByte ( &Version ); f.WriteTerLine ( hetID,False ); f.CreateWrite ( comment ); f.WriteInt ( &nSynonyms ); for (i=0;i0) { hetSynonym = new pstr[nSynonyms]; for (i=0;i12) { strcpy_n0 ( hetID,&(S[11]),3 ); i = AddHetName ( hetID ); if (l>15) { if (hetCompound[i]->comment) strcpy ( L,"\n" ); else L[0] = char(0); strcat ( L,&(S[15]) ); CutSpaces ( L,SCUTKEY_END ); CreateConcat ( hetCompound[i]->comment,L ); } } } void CHetCompounds::ConvertHETSYN ( cpstr S ) { ResName hetID; char L[100]; int l,i,j,k; l = strlen(S); if (l>12) { strcpy_n0 ( hetID,&(S[11]),3 ); i = AddHetName ( hetID ); if (l>15) { j = 15; do { while (S[j]==' ') j++; k = 0; if (S[j]) { while (S[j] && (S[j]!=';')) L[k++] = S[j++]; L[k--] = char(0); while ((k>0) && (L[k]==' ')) L[k--] = char(0); if (L[0]) { hetCompound[i]->AddKeyWord ( L,Closed ); Closed = (S[j]==';'); } if (S[j]) j++; } } while (S[j]); /* p1 = &(S[15]); do { p2 = strchr ( p1,';' ); if (p2) { c = *p2; *p2 = char(0); } strcpy_css ( L,p1 ); if (L[0]) hetCompound[i]->AddKeyWord ( L,Closed ); if (p2) { if (L[0]) Closed = True; *p2 = c; p1 = p2+1; } else if (L[0]) Closed = False; } while (p2); */ } } } void CHetCompounds::ConvertFORMUL ( cpstr S ) { ResName hetID; char L[100]; int l,i; l = strlen(S); if (l>13) { strcpy_n0 ( hetID,&(S[12]),3 ); i = AddHetName ( hetID ); if (l>18) { GetInteger ( hetCompound[i]->compNum,&(S[9]),2 ); hetCompound[i]->wc = S[18]; if (strlen(S)>19) { if (hetCompound[i]->Formula) strcpy ( L,"\n" ); else L[0] = char(0); strcat ( L,&(S[19]) ); CutSpaces ( L,SCUTKEY_END ); CreateConcat ( hetCompound[i]->Formula,L ); } } } } int CHetCompounds::AddHetName ( cpstr H ) { PPCHetCompound HC1; int i; i = 0; while (ihetID,H)) break; } i++; } if (i>=nHets) { HC1 = new PCHetCompound[nHets+1]; for (i=0;iHETNAM_PDBDump ( f ); for (i=0;iHETSYN_PDBDump ( f ); for (i=0;iFORMUL_PDBDump ( f ); } void CHetCompounds::MakeCIF ( PCMMCIFData CIF ) { PCMMCIFLoop Loop; pstr F; int RC; int i; if (!hetCompound) return; RC = CIF->AddLoop ( CIFCAT_CHEM_COMP,Loop ); if (RC!=CIFRC_Ok) { Loop->AddLoopTag ( CIFTAG_ID ); Loop->AddLoopTag ( CIFTAG_NAME ); Loop->AddLoopTag ( CIFTAG_NDB_SYNONYMS ); Loop->AddLoopTag ( CIFTAG_NDB_COMPONENT_NO ); Loop->AddLoopTag ( CIFTAG_FORMULA ); } F = NULL; for (i=0;iAddString ( hetCompound[i]->hetID ); hetCompound[i]->FormComString ( F ); Loop->AddString ( F ); hetCompound[i]->FormSynString ( F ); Loop->AddString ( F ); if (hetCompound[i]->compNum>MinInt4) Loop->AddInteger ( hetCompound[i]->compNum ); else Loop->AddNoData ( CIF_NODATA_QUESTION ); hetCompound[i]->FormForString ( F ); Loop->AddString ( F ); } if (F) delete[] F; } void CHetCompounds::GetCIF ( PCMMCIFData CIF ) { PCMMCIFLoop Loop; char L[100]; ResName hetID; pstr F,p1,p2; char c; int i,l,k,RC; FreeMemory(); Loop = CIF->GetLoop ( CIFCAT_CHEM_COMP ); if (!Loop) return; l = Loop->GetLoopLength(); F = NULL; for (i=0;iGetString ( hetCompound[k]->comment,CIFTAG_NAME,i,True ); RC = Loop->GetInteger ( hetCompound[k]->compNum, CIFTAG_NDB_COMPONENT_NO,i,True ); if (RC) hetCompound[i]->compNum = MinInt4; Loop->GetString ( hetCompound[k]->Formula,CIFTAG_FORMULA,i,True ); RC = Loop->GetString ( F,CIFTAG_NDB_SYNONYMS,i,True ); if ((!RC) && F ) { p1 = &(F[0]); while (*p1) { if (*p1=='\n') *p1 = ' '; p1++; } p1 = &(F[0]); do { p2 = strchr ( p1,';' ); if (p2) { c = *p2; *p2 = char(0); } strcpy_css ( L,p1 ); hetCompound[i]->AddKeyWord ( L,True ); if (p2) { *p2 = c; p1 = p2+1; } } while (p2); } hetCompound[i]->wc = ' '; } // CIF->DeleteLoop ( CIFCAT_CHEM_COMP ); if (F) delete[] F; } void CHetCompounds::Copy ( PCHetCompounds HetCompounds ) { int i; FreeMemory(); nHets = HetCompounds->nHets; if (nHets>0) { hetCompound = new PCHetCompound[nHets]; for (i=0;iCopy ( HetCompounds->hetCompound[i] ); } } } void CHetCompounds::write ( RCFile f ) { int i; byte Version=1; f.WriteByte ( &Version ); f.WriteInt ( &nHets ); for (i=0;iwrite ( f ); } void CHetCompounds::read ( RCFile f ) { int i; byte Version; FreeMemory(); f.ReadByte ( &Version ); f.ReadInt ( &nHets ); if (nHets>0) { hetCompound = new PCHetCompound[nHets]; for (i=0;iread ( f ); } } } MakeStreamFunctions(CHetCompounds) // ==================== CSSContainer ========================= PCContainerClass CSSContainer::MakeContainerClass ( int ClassID ) { switch (ClassID) { default : case ClassID_Template : return CClassContainer::MakeContainerClass(ClassID); case ClassID_Helix : return new CHelix(); case ClassID_Turn : return new CTurn (); } } MakeStreamFunctions(CSSContainer) // ================ CHelix =================== CHelix::CHelix() : CContainerClass() { InitHelix(); } CHelix::CHelix ( cpstr S ) : CContainerClass() { InitHelix(); ConvertPDBASCII ( S ); } CHelix::CHelix ( RPCStream Object ) : CContainerClass(Object) { InitHelix(); } CHelix::~CHelix() { if (comment) delete[] comment; } void CHelix::InitHelix() { serNum = 0; // serial number strcpy ( helixID ,"---" ); // helix ID strcpy ( initResName,"---" ); // name of the helix's initial residue strcpy ( initChainID,"" ); // chain ID for the chain // containing the helix initSeqNum = 0; // sequence number of the initial // residue strcpy ( initICode ,"" ); // insertion code of the initial // residue strcpy ( endResName ,"---" ); // name of the helix's terminal residue strcpy ( endChainID ,"" ); // chain ID for the chain // containing the helix endSeqNum = 0; // sequence number of the terminal // residue strcpy ( endICode ,"" ); // insertion code of the terminal // residue helixClass = 0; // helix class comment = NULL; // comment about the helix length = 0; // length of the helix } void CHelix::PDBASCIIDump ( pstr S, int N ) { UNUSED_ARGUMENT(N); // makes the ASCII PDB OBSLTE line number N // from the class' data strcpy ( S,"HELIX" ); PadSpaces ( S,80 ); PutInteger ( &(S[7]) ,serNum ,3 ); strcpy_n1 ( &(S[11]),helixID ,3 ); strcpy_n1 ( &(S[15]),initResName,3 ); if (initChainID[0]) S[19] = initChainID[0]; PutIntIns ( &(S[21]),initSeqNum ,4,initICode ); strcpy_n1 ( &(S[27]),endResName ,3 ); if (endChainID[0]) S[31] = endChainID[0]; PutIntIns ( &(S[33]),endSeqNum ,4,endICode ); PutInteger ( &(S[38]),helixClass ,2 ); if (comment) strcpy_n ( &(S[40]),comment ,30 ); PutInteger ( &(S[71]),length ,5 ); } void AddStructConfTags ( PCMMCIFLoop Loop ) { Loop->AddLoopTag ( CIFTAG_CONF_TYPE_ID ); Loop->AddLoopTag ( CIFTAG_ID ); Loop->AddLoopTag ( CIFTAG_PDB_ID ); Loop->AddLoopTag ( CIFTAG_BEG_LABEL_COMP_ID ); Loop->AddLoopTag ( CIFTAG_BEG_LABEL_ASYM_ID ); Loop->AddLoopTag ( CIFTAG_BEG_LABEL_SEQ_ID ); Loop->AddLoopTag ( CIFTAG_NDB_BEG_LABEL_INS_CODE_PDB ); Loop->AddLoopTag ( CIFTAG_END_LABEL_COMP_ID ); Loop->AddLoopTag ( CIFTAG_END_LABEL_ASYM_ID ); Loop->AddLoopTag ( CIFTAG_END_LABEL_SEQ_ID ); Loop->AddLoopTag ( CIFTAG_NDB_END_LABEL_INS_CODE_PDB ); Loop->AddLoopTag ( CIFTAG_NDB_HELIX_CLASS_PDB ); Loop->AddLoopTag ( CIFTAG_DETAILS ); Loop->AddLoopTag ( CIFTAG_NDB_LENGTH ); } #define HelixTypeID "HELX_P" void CHelix::MakeCIF ( PCMMCIFData CIF, int N ) { UNUSED_ARGUMENT(N); PCMMCIFLoop Loop; int RC; RC = CIF->AddLoop ( CIFCAT_STRUCT_CONF,Loop ); if (RC!=CIFRC_Ok) // the category was (re)created, provide tags AddStructConfTags ( Loop ); Loop->AddString ( pstr(HelixTypeID) ); Loop->AddInteger ( serNum ); Loop->AddString ( helixID ); Loop->AddString ( initResName ); Loop->AddString ( initChainID ); Loop->AddInteger ( initSeqNum ); Loop->AddString ( initICode,True ); Loop->AddString ( endResName ); Loop->AddString ( endChainID ); Loop->AddInteger ( endSeqNum ); Loop->AddString ( endICode ,True ); Loop->AddInteger ( helixClass ); Loop->AddString ( comment ); Loop->AddInteger ( length ); } int CHelix::ConvertPDBASCII ( cpstr S ) { char L[100]; GetInteger ( serNum ,&(S[7]) ,3 ); strcpy_ncss ( helixID ,&(S[11]),3 ); strcpy_ncss ( initResName,&(S[15]),3 ); strcpy_ncss ( initChainID,&(S[19]),1 ); GetIntIns ( initSeqNum,initICode,&(S[21]),4 ); strcpy_ncss ( endResName ,&(S[27]),3 ); strcpy_ncss ( endChainID ,&(S[31]),1 ); GetIntIns ( endSeqNum ,endICode ,&(S[33]),4 ); GetInteger ( helixClass ,&(S[38]),2 ); strcpy_ncss ( L ,&(S[40]),30 ); CreateCopy ( comment ,L ); GetInteger ( length ,&(S[71]),5 ); return 0; } void CHelix::GetCIF ( PCMMCIFData CIF, int & Signal ) { PCMMCIFLoop Loop; int RC,l; pstr F; Boolean Done; Loop = CIF->GetLoop ( CIFCAT_STRUCT_CONF ); if (!Loop) { Signal = -1; // signal to finish processing of this structure return; } l = Loop->GetLoopLength(); Done = Signal>=l; while (!Done) { F = Loop->GetString ( CIFTAG_CONF_TYPE_ID,Signal,RC ); if ((!RC) && F) Done = (strcmp(F,HelixTypeID)==0); else Done = False; if (!Done) { Signal++; Done = Signal>=l; } } if (Signal>=l) { Signal = -1; // finish processing of Helix return; } Loop->DeleteField ( CIFTAG_CONF_TYPE_ID,Signal ); if (CIFGetInteger(serNum,Loop,CIFTAG_ID,Signal)) return; CIFGetString ( helixID ,Loop,CIFTAG_PDB_ID, Signal,sizeof(helixID),pstr(" ") ); CIFGetString ( initResName,Loop,CIFTAG_BEG_LABEL_COMP_ID, Signal,sizeof(initResName),pstr(" ") ); CIFGetString ( initChainID,Loop,CIFTAG_BEG_LABEL_ASYM_ID, Signal,sizeof(initChainID),pstr("") ); CIFGetString ( initICode ,Loop,CIFTAG_NDB_BEG_LABEL_INS_CODE_PDB, Signal,sizeof(initICode),pstr("") ); if (CIFGetInteger(initSeqNum,Loop,CIFTAG_BEG_LABEL_SEQ_ID,Signal)) return; CIFGetString ( endResName,Loop,CIFTAG_END_LABEL_COMP_ID, Signal,sizeof(endResName),pstr(" ") ); CIFGetString ( endChainID,Loop,CIFTAG_END_LABEL_ASYM_ID, Signal,sizeof(endChainID),pstr("") ); CIFGetString ( endICode ,Loop,CIFTAG_NDB_END_LABEL_INS_CODE_PDB, Signal,sizeof(endICode),pstr("") ); if (CIFGetInteger(endSeqNum,Loop,CIFTAG_END_LABEL_SEQ_ID,Signal)) return; if (CIFGetInteger(helixClass,Loop, CIFTAG_NDB_HELIX_CLASS_PDB,Signal)) return; CreateCopy ( comment,Loop->GetString(CIFTAG_DETAILS,Signal,RC)); Loop->DeleteField ( CIFTAG_DETAILS,Signal ); if (CIFGetInteger(length,Loop,CIFTAG_NDB_LENGTH,Signal)) return; Signal++; } void CHelix::Copy ( PCContainerClass Helix ) { serNum = PCHelix(Helix)->serNum; initSeqNum = PCHelix(Helix)->initSeqNum; endSeqNum = PCHelix(Helix)->endSeqNum; helixClass = PCHelix(Helix)->helixClass; length = PCHelix(Helix)->length; strcpy ( helixID ,PCHelix(Helix)->helixID ); strcpy ( initResName,PCHelix(Helix)->initResName ); strcpy ( initChainID,PCHelix(Helix)->initChainID ); strcpy ( initICode ,PCHelix(Helix)->initICode ); strcpy ( endResName ,PCHelix(Helix)->endResName ); strcpy ( endChainID ,PCHelix(Helix)->endChainID ); strcpy ( endICode ,PCHelix(Helix)->endICode ); CreateCopy ( comment,PCHelix(Helix)->comment ); } void CHelix::write ( RCFile f ) { byte Version=1; f.WriteByte ( &Version ); f.WriteInt ( &serNum ); f.WriteInt ( &initSeqNum ); f.WriteInt ( &endSeqNum ); f.WriteInt ( &helixClass ); f.WriteInt ( &length ); f.WriteTerLine ( helixID ,False ); f.WriteTerLine ( initResName,False ); f.WriteTerLine ( initChainID,False ); f.WriteTerLine ( initICode ,False ); f.WriteTerLine ( endResName ,False ); f.WriteTerLine ( endChainID ,False ); f.WriteTerLine ( endICode ,False ); f.CreateWrite ( comment ); } void CHelix::read ( RCFile f ) { byte Version; f.ReadByte ( &Version ); f.ReadInt ( &serNum ); f.ReadInt ( &initSeqNum ); f.ReadInt ( &endSeqNum ); f.ReadInt ( &helixClass ); f.ReadInt ( &length ); f.ReadTerLine ( helixID ,False ); f.ReadTerLine ( initResName,False ); f.ReadTerLine ( initChainID,False ); f.ReadTerLine ( initICode ,False ); f.ReadTerLine ( endResName ,False ); f.ReadTerLine ( endChainID ,False ); f.ReadTerLine ( endICode ,False ); f.CreateRead ( comment ); } MakeStreamFunctions(CHelix) // ================ CStrand ===================== CStrand::CStrand () : CStream() { InitStrand(); } CStrand::CStrand ( RPCStream Object ) : CStream(Object) { InitStrand(); } CStrand::~CStrand() { } void CStrand::InitStrand() { initSeqNum = MinInt4; endSeqNum = MinInt4; sense = 0; curResSeq = MinInt4; prevResSeq = MinInt4; strandNo = 0; strcpy ( sheetID ,"sheet_0" ); strcpy ( initResName," " ); strcpy ( initChainID,"" ); strcpy ( initICode ,"" ); strcpy ( endResName ," " ); strcpy ( endChainID ,"" ); strcpy ( endICode ,"" ); strcpy ( curAtom ," " ); strcpy ( curResName ," " ); strcpy ( curChainID ,"" ); strcpy ( curICode ,"" ); strcpy ( prevAtom ," " ); strcpy ( prevResName," " ); strcpy ( prevChainID,"" ); strcpy ( prevICode ,"" ); } void CStrand::PDBASCIIDump ( pstr S ) { // Finishes making the ASCII PDB SHEET line number N // from the class' data. Making is initiated by CSheet. strcpy_n1 ( &(S[17]),initResName,3 ); if (initChainID[0]) S[21] = initChainID[0]; PutIntIns ( &(S[22]),initSeqNum ,4,initICode ); strcpy_n1 ( &(S[28]),endResName ,3 ); if (endChainID[0]) S[32] = endChainID[0]; PutIntIns ( &(S[33]),endSeqNum ,4,endICode ); PutInteger ( &(S[38]),sense ,2 ); strcpy_n1 ( &(S[41]),curAtom ,4 ); strcpy_n1 ( &(S[45]),curResName ,3 ); if (curChainID[0]) S[49] = curChainID[0]; PutIntIns ( &(S[50]),curResSeq ,4,curICode ); strcpy_n1 ( &(S[56]),prevAtom ,4 ); strcpy_n1 ( &(S[60]),prevResName,3 ); if (prevChainID[0]) S[64] = prevChainID[0]; PutIntIns ( &(S[65]),prevResSeq ,4,prevICode ); } void CStrand::MakeCIF ( PCMMCIFData CIF ) { PCMMCIFLoop Loop; int RC; RC = CIF->AddLoop ( CIFCAT_STRUCT_SHEET_RANGE,Loop ); if (RC!=CIFRC_Ok) { // the category was (re)created, provide tags Loop->AddLoopTag ( CIFTAG_SHEET_ID ); Loop->AddLoopTag ( CIFTAG_ID ); Loop->AddLoopTag ( CIFTAG_BEG_LABEL_COMP_ID ); Loop->AddLoopTag ( CIFTAG_BEG_LABEL_ASYM_ID ); Loop->AddLoopTag ( CIFTAG_BEG_LABEL_SEQ_ID ); Loop->AddLoopTag ( CIFTAG_NDB_BEG_LABEL_INS_CODE_PDB ); Loop->AddLoopTag ( CIFTAG_END_LABEL_COMP_ID ); Loop->AddLoopTag ( CIFTAG_END_LABEL_ASYM_ID ); Loop->AddLoopTag ( CIFTAG_END_LABEL_SEQ_ID ); Loop->AddLoopTag ( CIFTAG_NDB_END_LABEL_INS_CODE_PDB ); } Loop->AddString ( sheetID ); Loop->AddInteger ( strandNo ); Loop->AddString ( initResName ); Loop->AddString ( initChainID ); Loop->AddInteger ( initSeqNum ); Loop->AddString ( initICode,True ); Loop->AddString ( endResName ); Loop->AddString ( endChainID ); Loop->AddInteger ( endSeqNum ); Loop->AddString ( endICode ,True ); } int CStrand::ConvertPDBASCII ( cpstr S ) { GetInteger ( strandNo ,&(S[7]) ,3 ); strcpy_ncss ( sheetID ,&(S[11]) ,3 ); strcpy_ncss ( initResName,&(S[17]) ,3 ); strcpy_ncss ( initChainID,&(S[21]) ,1 ); GetIntIns ( initSeqNum ,initICode,&(S[22]),4 ); strcpy_ncss ( endResName ,&(S[28]) ,3 ); strcpy_ncss ( endChainID ,&(S[32]) ,1 ); GetIntIns ( endSeqNum ,endICode ,&(S[33]),4 ); GetInteger ( sense ,&(S[38]) ,2 ); GetString ( curAtom ,&(S[41]) ,4 ); strcpy_ncss ( curResName ,&(S[45]) ,3 ); strcpy_ncss ( curChainID ,&(S[49]) ,1 ); GetIntIns ( curResSeq ,curICode ,&(S[50]),4 ); GetString ( prevAtom ,&(S[56]) ,4 ); strcpy_ncss ( prevResName,&(S[60]) ,3 ); strcpy_ncss ( prevChainID,&(S[64]) ,1 ); GetIntIns ( prevResSeq ,prevICode,&(S[65]),4 ); return 0; } int CStrand::GetCIF ( PCMMCIFData CIF, cpstr sheet_id ) { PCMMCIFLoop Loop; int RC,l,i,sNo; pstr F; Loop = CIF->GetLoop ( CIFCAT_STRUCT_SHEET_RANGE ); if (Loop) { l = Loop->GetLoopLength(); i = 0; while (iGetString ( CIFTAG_SHEET_ID,i,RC ); if (F && (!RC)) { if (!strcmp(F,sheet_id)) { strcpy ( sheetID,sheet_id ); if (CIFGetInteger(sNo,Loop,CIFTAG_ID,i)) return i; if (sNo==strandNo) { CIFGetString ( initResName,Loop,CIFTAG_BEG_LABEL_COMP_ID, i,sizeof(initResName),pstr(" ") ); CIFGetString ( initChainID,Loop,CIFTAG_BEG_LABEL_ASYM_ID, i,sizeof(initChainID),pstr("") ); CIFGetString ( initICode,Loop, CIFTAG_NDB_BEG_LABEL_INS_CODE_PDB, i,sizeof(initICode),pstr("") ); if (CIFGetInteger(initSeqNum,Loop, CIFTAG_BEG_LABEL_SEQ_ID,i)) return i; CIFGetString ( endResName,Loop,CIFTAG_END_LABEL_COMP_ID, i,sizeof(endResName),pstr(" ") ); CIFGetString ( endChainID,Loop,CIFTAG_END_LABEL_ASYM_ID, i,sizeof(endChainID),pstr("") ); CIFGetString ( endICode ,Loop, CIFTAG_NDB_END_LABEL_INS_CODE_PDB, i,sizeof(endICode),pstr("") ); if (CIFGetInteger(endSeqNum,Loop, CIFTAG_END_LABEL_SEQ_ID,i)) return i; Loop->DeleteRow ( i ); i = l+100; // break the loop } } } i++; } } return 0; } void CStrand::Copy ( PCStrand Strand ) { initSeqNum = Strand->initSeqNum; endSeqNum = Strand->endSeqNum; sense = Strand->sense; curResSeq = Strand->curResSeq; prevResSeq = Strand->prevResSeq; strcpy ( initResName,Strand->initResName ); strcpy ( initChainID,Strand->initChainID ); strcpy ( initICode ,Strand->initICode ); strcpy ( endResName ,Strand->endResName ); strcpy ( endChainID ,Strand->endChainID ); strcpy ( endICode ,Strand->endICode ); strcpy ( curAtom ,Strand->curAtom ); strcpy ( curResName ,Strand->curResName ); strcpy ( curChainID ,Strand->curChainID ); strcpy ( curICode ,Strand->curICode ); strcpy ( prevAtom ,Strand->prevAtom ); strcpy ( prevResName,Strand->prevResName ); strcpy ( prevChainID,Strand->prevChainID ); strcpy ( prevICode ,Strand->prevICode ); } void CStrand::write ( RCFile f ) { byte Version=1; f.WriteByte ( &Version ); f.WriteInt ( &initSeqNum ); f.WriteInt ( &endSeqNum ); f.WriteInt ( &sense ); f.WriteInt ( &curResSeq ); f.WriteInt ( &prevResSeq ); f.WriteTerLine ( initResName,False ); f.WriteTerLine ( initChainID,False ); f.WriteTerLine ( initICode ,False ); f.WriteTerLine ( endResName ,False ); f.WriteTerLine ( endChainID ,False ); f.WriteTerLine ( endICode ,False ); f.WriteTerLine ( curAtom ,False ); f.WriteTerLine ( curResName ,False ); f.WriteTerLine ( curChainID ,False ); f.WriteTerLine ( curICode ,False ); f.WriteTerLine ( prevAtom ,False ); f.WriteTerLine ( prevResName,False ); f.WriteTerLine ( prevChainID,False ); f.WriteTerLine ( prevICode ,False ); } void CStrand::read ( RCFile f ) { byte Version; f.ReadByte ( &Version ); f.ReadInt ( &initSeqNum ); f.ReadInt ( &endSeqNum ); f.ReadInt ( &sense ); f.ReadInt ( &curResSeq ); f.ReadInt ( &prevResSeq ); f.ReadTerLine ( initResName,False ); f.ReadTerLine ( initChainID,False ); f.ReadTerLine ( initICode ,False ); f.ReadTerLine ( endResName ,False ); f.ReadTerLine ( endChainID ,False ); f.ReadTerLine ( endICode ,False ); f.ReadTerLine ( curAtom ,False ); f.ReadTerLine ( curResName ,False ); f.ReadTerLine ( curChainID ,False ); f.ReadTerLine ( curICode ,False ); f.ReadTerLine ( prevAtom ,False ); f.ReadTerLine ( prevResName,False ); f.ReadTerLine ( prevChainID,False ); f.ReadTerLine ( prevICode ,False ); } MakeStreamFunctions(CStrand) // ================ CSheet =================== CSheet::CSheet() : CStream() { InitSheet(); } CSheet::CSheet ( RPCStream Object ) : CStream(Object) { InitSheet(); } CSheet::~CSheet() { FreeMemory(); } void CSheet::InitSheet() { nStrands = 0; sheetID[0] = char(0); Strand = NULL; } void CSheet::FreeMemory() { int i; if (Strand) { for (i=0;iPDBASCIIDump ( S ); f.WriteLine ( S ); } } void CSheet::OrderSheet() { int i,k; PPCStrand Strand1; k = 0; for (i=0;iAddLoop ( CIFCAT_STRUCT_SHEET,Loop ); if (RC!=CIFRC_Ok) { // the category was (re)created, provide tags Loop->AddLoopTag ( CIFTAG_SHEET_ID ); Loop->AddLoopTag ( CIFTAG_NUMBER_STRANDS ); } Loop->AddString ( sheetID ); Loop->AddInteger ( nStrands ); for (i=0;iMakeCIF ( CIF ); if (Strand[i]->sense!=0) isSense = True; } if (nStrands>1) { if (isSense) { RC = CIF->AddLoop ( CIFCAT_STRUCT_SHEET_ORDER,Loop ); if (RC!=CIFRC_Ok) { // the category was (re)created, provide tags Loop->AddLoopTag ( CIFTAG_SHEET_ID ); Loop->AddLoopTag ( CIFTAG_RANGE_ID_1 ); Loop->AddLoopTag ( CIFTAG_RANGE_ID_2 ); Loop->AddLoopTag ( CIFTAG_SENSE ); } for (i=1;iAddString ( sheetID ); Loop->AddInteger ( Strand[i-1]->strandNo ); Loop->AddInteger ( Strand[i] ->strandNo ); if (Strand[i]->sense>0) Loop->AddString ( pstr("parallel") ); else Loop->AddString ( pstr("anti-parallel") ); } } RC = CIF->AddLoop ( CIFCAT_STRUCT_SHEET_HBOND,Loop ); if (RC!=CIFRC_Ok) { // the category was (re)created, provide tags Loop->AddLoopTag ( CIFTAG_SHEET_ID ); Loop->AddLoopTag ( CIFTAG_RANGE_ID_1 ); Loop->AddLoopTag ( CIFTAG_RANGE_ID_2 ); Loop->AddLoopTag ( CIFTAG_RANGE_1_BEG_LABEL_ATOM_ID ); Loop->AddLoopTag ( CIFTAG_NDB_RANGE_1_BEG_LABEL_COMP_ID ); Loop->AddLoopTag ( CIFTAG_NDB_RANGE_1_BEG_LABEL_ASYM_ID ); Loop->AddLoopTag ( CIFTAG_RANGE_1_BEG_LABEL_SEQ_ID ); Loop->AddLoopTag ( CIFTAG_NDB_RANGE_1_BEG_LABEL_INS_CODE ); Loop->AddLoopTag ( CIFTAG_RANGE_1_END_LABEL_ATOM_ID ); Loop->AddLoopTag ( CIFTAG_NDB_RANGE_1_END_LABEL_COMP_ID ); Loop->AddLoopTag ( CIFTAG_NDB_RANGE_1_END_LABEL_ASYM_ID ); Loop->AddLoopTag ( CIFTAG_RANGE_1_END_LABEL_SEQ_ID ); Loop->AddLoopTag ( CIFTAG_NDB_RANGE_1_END_LABEL_INS_CODE ); } for (i=1;iAddString ( sheetID ); Loop->AddInteger ( Strand[i-1]->strandNo ); Loop->AddInteger ( Strand[i]->strandNo ); Loop->AddString ( Strand[i]->curAtom ); Loop->AddString ( Strand[i]->curResName ); Loop->AddString ( Strand[i]->curChainID ); Loop->AddInteger ( Strand[i]->curResSeq ); Loop->AddString ( Strand[i]->curICode ,True ); Loop->AddString ( Strand[i]->prevAtom ); Loop->AddString ( Strand[i]->prevResName ); Loop->AddString ( Strand[i]->prevChainID ); Loop->AddInteger ( Strand[i]->prevResSeq ); Loop->AddString ( Strand[i]->prevICode,True ); } } } int CSheet::ConvertPDBASCII ( cpstr S ) { int i,k,ns; SheetID SID; PPCStrand Strand1; GetInteger ( k ,&(S[7]) ,3 ); strcpy_ncss ( SID,&(S[11]),3 ); GetInteger ( ns ,&(S[14]),2 ); // if (!SID[0]) return Error_NoSheetID; if (!sheetID[0]) strcpy ( sheetID,SID ); else if (strcmp(sheetID,SID)) return Error_WrongSheetID; if (k<=0) return Error_WrongStrandNo; ns = IMax(k,ns); if (!Strand) { Strand = new PCStrand[ns]; for (i=0;inStrands) { Strand1 = new PCStrand[ns]; for (i=0;iConvertPDBASCII ( S ); } void CSheet::TryStrand ( int strand_no ) { int i,k; PPCStrand Strand1; k = -1; for (i=0;(istrandNo==strand_no) k = i; if (k<0) { Strand1 = new PCStrand[nStrands+1]; for (i=0;istrandNo = strand_no; nStrands++; } } void CSheet::CIFFindStrands ( PCMMCIFData CIF, cpstr Category ) { // just look for all strands mentioned for the sheet PCMMCIFLoop Loop; pstr F; int RC,i,l,sNo; Loop = CIF->GetLoop ( Category ); if (Loop) { l = Loop->GetLoopLength(); for (i=0;iGetString ( CIFTAG_SHEET_ID,i,RC ); if (F && (!RC)) { if (!strcmp(F,sheetID)) { if (!Loop->GetInteger(sNo,CIFTAG_ID,i)) TryStrand ( sNo ); if (!Loop->GetInteger(sNo,CIFTAG_RANGE_ID_1,i)) TryStrand ( sNo ); if (!Loop->GetInteger(sNo,CIFTAG_RANGE_ID_2,i)) TryStrand ( sNo ); } } } } } int CSheet::GetStrand ( int strand_no ) { int i; for (i=0;istrandNo==strand_no) return i; } return -1; } int CSheet::GetCIF ( PCMMCIFData CIF ) { PCMMCIFLoop Loop; int i,ns,l,k,k2,RC,sNo; pstr F; ivector pair; Boolean Ok; pair = NULL; // First find all strands and create // the corresponding classes. The CIF fields // are not removed at this stage. CIFFindStrands ( CIF,CIFCAT_STRUCT_SHEET_ORDER ); CIFFindStrands ( CIF,CIFCAT_STRUCT_SHEET_RANGE ); CIFFindStrands ( CIF,CIFCAT_STRUCT_SHEET_HBOND ); // Check number of strands Loop = CIF->GetLoop ( CIFCAT_STRUCT_SHEET ); if (Loop) { l = Loop->GetLoopLength(); i = 0; while (iGetString ( CIFTAG_SHEET_ID,i,RC ); if (F && (!RC)) { if (!strcmp(F,sheetID)) { RC = CIFGetInteger1 ( ns,Loop,CIFTAG_NUMBER_STRANDS,i ); if ((!RC) && (ns!=nStrands)) return Error_WrongNumberOfStrands; Loop->DeleteRow ( i ); i = l+100; // break loop } } i++; } } // Read each strand RC = 0; for (i=0;(iGetCIF ( CIF,sheetID ); if (RC) return RC; if (nStrands>1) { GetVectorMemory ( pair,nStrands,0 ); for (i=0;iGetLoop ( CIFCAT_STRUCT_SHEET_ORDER ); if (Loop) { Ok = True; l = Loop->GetLoopLength(); for (i=0;(iGetString ( CIFTAG_SHEET_ID,i,RC ); if (F && (!RC)) { if (!strcmp(F,sheetID)) { if (!Loop->GetInteger(sNo,CIFTAG_RANGE_ID_1,i)) { k = GetStrand ( sNo ); if ((k>=0) && (!Loop->GetInteger(sNo,CIFTAG_RANGE_ID_2,i))) { pair[k] = GetStrand ( sNo ); if (pair[k]>=0) { F = Loop->GetString ( CIFTAG_SENSE,i,RC ); if (F && (!RC)) { if (!strcasecmp(F,"anti-parallel")) Strand[pair[k]]->sense = -1; else if (!strcasecmp(F,"parallel")) Strand[pair[k]]->sense = 1; } Loop->DeleteRow ( i ); } else Ok = False; } else Ok = False; } else Ok = False; } } } if (!Ok) { FreeVectorMemory ( pair,0 ); return Error_WrongSheetOrder; } } Loop = CIF->GetLoop ( CIFCAT_STRUCT_SHEET_HBOND ); if (Loop) { Ok = True; l = Loop->GetLoopLength(); for (i=0;(iGetString ( CIFTAG_SHEET_ID,i,RC ); if (F && (!RC)) { if (!strcmp(F,sheetID)) { if (!Loop->GetInteger(sNo,CIFTAG_RANGE_ID_1,i)) { k = GetStrand ( sNo ); if ((k>=0) && (!Loop->GetInteger(sNo,CIFTAG_RANGE_ID_1,i))) { k2 = GetStrand ( sNo ); if (k2>=0) { if (pair[k]==k2) { CIFGetString ( Strand[k2]->curAtom,Loop, CIFTAG_RANGE_1_BEG_LABEL_ATOM_ID, i,sizeof(Strand[k2]->curAtom), pstr(" ") ); CIFGetString ( Strand[k2]->curResName,Loop, CIFTAG_NDB_RANGE_1_BEG_LABEL_COMP_ID, i,sizeof(Strand[k2]->curResName), pstr(" ") ); CIFGetString ( Strand[k2]->curChainID,Loop, CIFTAG_NDB_RANGE_1_BEG_LABEL_ASYM_ID, i,sizeof(Strand[k2]->curChainID), pstr(" ") ); if (CIFGetInteger(Strand[k2]->curResSeq,Loop, CIFTAG_RANGE_1_BEG_LABEL_SEQ_ID,i)) { FreeVectorMemory ( pair,0 ); return i; } CIFGetString ( Strand[k2]->curICode,Loop, CIFTAG_NDB_RANGE_1_BEG_LABEL_INS_CODE, i,sizeof(Strand[k2]->curICode), pstr(" ") ); CIFGetString ( Strand[k2]->prevAtom,Loop, CIFTAG_RANGE_1_END_LABEL_ATOM_ID, i,sizeof(Strand[k2]->prevAtom), pstr(" ") ); CIFGetString ( Strand[k2]->prevResName,Loop, CIFTAG_NDB_RANGE_1_END_LABEL_COMP_ID, i,sizeof(Strand[k2]->prevResName), pstr(" ") ); CIFGetString ( Strand[k2]->prevChainID,Loop, CIFTAG_NDB_RANGE_1_END_LABEL_ASYM_ID, i,sizeof(Strand[k2]->prevChainID), pstr(" ") ); if (CIFGetInteger(Strand[k2]->prevResSeq,Loop, CIFTAG_RANGE_1_END_LABEL_SEQ_ID,i)) { FreeVectorMemory ( pair,0 ); return i; } CIFGetString ( Strand[k2]->prevICode,Loop, CIFTAG_NDB_RANGE_1_END_LABEL_INS_CODE, i,sizeof(Strand[k2]->prevICode), pstr(" ") ); Loop->DeleteRow ( i ); } else Ok = False; } else Ok = False; } else Ok = False; } else Ok = False; } } } if (!Ok) { FreeVectorMemory ( pair,0 ); return Error_HBondInconsistency; } } } FreeVectorMemory ( pair,0 ); return 0; } void CSheet::Copy ( PCSheet Sheet ) { int i; FreeMemory(); nStrands = Sheet->nStrands; if (nStrands>0) { Strand = new PCStrand[nStrands]; for (i=0;iStrand[i]) { Strand[i] = new CStrand(); Strand[i]->Copy ( Sheet->Strand[i] ); } else Strand[i] = NULL; } strcpy ( sheetID,Sheet->sheetID ); } void CSheet::write ( RCFile f ) { int i; byte Version=1; f.WriteByte ( &Version ); f.WriteInt ( &nStrands ); for (i=0;i0) { Strand = new PCStrand[nStrands]; for (i=0;iPDBASCIIDump ( f ); } void CSheets::MakeCIF ( PCMMCIFData CIF ) { int i; if (Sheet) for (i=0;iMakeCIF ( CIF ); } int CSheets::ConvertPDBASCII ( cpstr S ) { SheetID sheetID; int i,k; PPCSheet Sheet1; strcpy_ncss ( sheetID,&(S[11]),3 ); // if (!sheetID[0]) return Error_NoSheetID; k = -1; for (i=0;isheetID)) { k = i; break; } } if (k<0) { Sheet1 = new PCSheet[nSheets+1]; for (i=0;iConvertPDBASCII ( S ); } void CSheets::CIFFindSheets ( PCMMCIFData CIF, cpstr Category ) { PCMMCIFLoop Loop; int RC,i,j,k,l; pstr F; PPCSheet Sheet1; Loop = CIF->GetLoop ( Category ); if (Loop) { l = Loop->GetLoopLength(); for (i=0;iGetString ( CIFTAG_SHEET_ID,i,RC ); if (F && (!RC)) { k = -1; j = 0; while ((jsheetID)) k = j; } j++; } if (k<0) { Sheet1 = new PCSheet[nSheets+1]; for (i=0;isheetID,F ); nSheets++; } } } } } int CSheets::GetCIF ( PCMMCIFData CIF ) { int i,RC; FreeMemory(); // First find all sheet names and create // the corresponding classes. The CIF fields // are not removed at this stage. CIFFindSheets ( CIF,CIFCAT_STRUCT_SHEET ); CIFFindSheets ( CIF,CIFCAT_STRUCT_SHEET_ORDER ); CIFFindSheets ( CIF,CIFCAT_STRUCT_SHEET_RANGE ); CIFFindSheets ( CIF,CIFCAT_STRUCT_SHEET_HBOND ); // Read each sheet i = 0; RC = 0; while ((iGetCIF ( CIF ); i++; } return RC; } void CSheets::Copy ( PCSheets Sheets ) { int i; FreeMemory(); if (Sheets->nSheets>0) { nSheets = Sheets->nSheets; Sheet = new PCSheet[nSheets]; for (i=0;iSheet[i]) { Sheet[i] = new CSheet(); Sheet[i]->Copy ( Sheets->Sheet[i] ); } else Sheet[i] = NULL; } } void CSheets::write ( RCFile f ) { int i; byte Version=1; f.WriteByte ( &Version ); f.WriteInt ( &nSheets ); for (i=0;i0) { Sheet = new PCSheet[nSheets]; for (i=0;iAddLoop ( CIFCAT_STRUCT_CONF,Loop ); if (RC!=CIFRC_Ok) // the category was (re)created, provide tags AddStructConfTags ( Loop ); Loop->AddString ( pstr(TurnTypeID) ); Loop->AddInteger ( serNum ); Loop->AddString ( turnID ); Loop->AddString ( initResName ); Loop->AddString ( initChainID ); Loop->AddInteger ( initSeqNum ); Loop->AddString ( initICode,True ); Loop->AddString ( endResName ); Loop->AddString ( endChainID ); Loop->AddInteger ( endSeqNum ); Loop->AddString ( endICode ,True ); Loop->AddNoData ( CIF_NODATA_QUESTION ); Loop->AddString ( comment ); Loop->AddNoData ( CIF_NODATA_QUESTION ); } int CTurn::ConvertPDBASCII ( cpstr S ) { char L[100]; GetInteger ( serNum ,&(S[7]) ,3 ); strcpy_ncss ( turnID ,&(S[11]),3 ); strcpy_ncss ( initResName,&(S[15]),3 ); strcpy_ncss ( initChainID,&(S[19]),1 ); GetIntIns ( initSeqNum,initICode,&(S[20]),4 ); strcpy_ncss ( endResName ,&(S[26]),3 ); strcpy_ncss ( endChainID ,&(S[30]),1 ); GetIntIns ( endSeqNum ,endICode ,&(S[31]),4 ); strcpy_ncss ( L ,&(S[40]),30 ); CreateCopy ( comment ,L ); return 0; } void CTurn::GetCIF ( PCMMCIFData CIF, int & Signal ) { PCMMCIFLoop Loop; int RC,l; pstr F; Boolean Done; Loop = CIF->GetLoop ( CIFCAT_STRUCT_CONF ); if (!Loop) { Signal = -1; // signal to finish processing of this structure return; } l = Loop->GetLoopLength(); Done = Signal>=l; while (!Done) { F = Loop->GetString ( CIFTAG_CONF_TYPE_ID,Signal,RC ); if ((!RC) && F) Done = (strcmp(F,TurnTypeID)==0); else Done = False; if (!Done) { Signal++; Done = Signal>=l; } } if (Signal>=l) { Signal = -1; // finish processing of Turn return; } Loop->DeleteField ( CIFTAG_CONF_TYPE_ID,Signal ); if (CIFGetInteger(serNum,Loop,CIFTAG_ID,Signal)) return; CIFGetString ( turnID,Loop,CIFTAG_PDB_ID,Signal, sizeof(turnID),pstr(" ") ); CIFGetString ( initResName,Loop,CIFTAG_BEG_LABEL_COMP_ID, Signal,sizeof(initResName),pstr(" ") ); CIFGetString ( initChainID,Loop,CIFTAG_BEG_LABEL_ASYM_ID, Signal,sizeof(initChainID),pstr(" ") ); CIFGetString ( initICode ,Loop,CIFTAG_NDB_BEG_LABEL_INS_CODE_PDB, Signal,sizeof(initICode),pstr(" ") ); if (CIFGetInteger(initSeqNum,Loop,CIFTAG_BEG_LABEL_SEQ_ID,Signal)) return; CIFGetString ( endResName,Loop,CIFTAG_END_LABEL_COMP_ID, Signal,sizeof(endResName),pstr(" ") ); CIFGetString ( endChainID,Loop,CIFTAG_END_LABEL_ASYM_ID, Signal,sizeof(endChainID),pstr(" ") ); CIFGetString ( endICode ,Loop,CIFTAG_NDB_END_LABEL_INS_CODE_PDB, Signal,sizeof(endICode),pstr(" ") ); if (CIFGetInteger(endSeqNum,Loop,CIFTAG_END_LABEL_SEQ_ID,Signal)) return; CreateCopy ( comment,Loop->GetString(CIFTAG_DETAILS,Signal,RC)); Loop->DeleteField ( CIFTAG_DETAILS,Signal ); Signal++; } void CTurn::Copy ( PCContainerClass Turn ) { serNum = PCTurn(Turn)->serNum; initSeqNum = PCTurn(Turn)->initSeqNum; endSeqNum = PCTurn(Turn)->endSeqNum; strcpy ( turnID ,PCTurn(Turn)->turnID ); strcpy ( initResName,PCTurn(Turn)->initResName ); strcpy ( initChainID,PCTurn(Turn)->initChainID ); strcpy ( initICode ,PCTurn(Turn)->initICode ); strcpy ( endResName ,PCTurn(Turn)->endResName ); strcpy ( endChainID ,PCTurn(Turn)->endChainID ); strcpy ( endICode ,PCTurn(Turn)->endICode ); CreateCopy ( comment,PCTurn(Turn)->comment ); } void CTurn::write ( RCFile f ) { byte Version=1; f.WriteByte ( &Version ); f.WriteInt ( &serNum ); f.WriteInt ( &initSeqNum ); f.WriteInt ( &endSeqNum ); f.WriteTerLine ( turnID ,False ); f.WriteTerLine ( initResName,False ); f.WriteTerLine ( initChainID,False ); f.WriteTerLine ( initICode ,False ); f.WriteTerLine ( endResName ,False ); f.WriteTerLine ( endChainID ,False ); f.WriteTerLine ( endICode ,False ); f.CreateWrite ( comment ); } void CTurn::read ( RCFile f ) { byte Version; f.ReadByte ( &Version ); f.ReadInt ( &serNum ); f.ReadInt ( &initSeqNum ); f.ReadInt ( &endSeqNum ); f.ReadTerLine ( turnID ,False ); f.ReadTerLine ( initResName,False ); f.ReadTerLine ( initChainID,False ); f.ReadTerLine ( initICode ,False ); f.ReadTerLine ( endResName ,False ); f.ReadTerLine ( endChainID ,False ); f.ReadTerLine ( endICode ,False ); f.CreateRead ( comment ); } MakeStreamFunctions(CTurn) // =================== CLinkContainer ======================== PCContainerClass CLinkContainer::MakeContainerClass ( int ClassID ) { switch (ClassID) { default : case ClassID_Template : return CClassContainer::MakeContainerClass(ClassID); case ClassID_Link : return new CLink(); } } MakeStreamFunctions(CLinkContainer) // ======================== CLink =========================== CLink::CLink() : CContainerClass() { InitLink(); } CLink::CLink ( cpstr S ) : CContainerClass() { InitLink(); ConvertPDBASCII ( S ); } CLink::CLink ( RPCStream Object ) : CContainerClass(Object) { InitLink(); } CLink::~CLink() {} void CLink::InitLink() { strcpy ( atName1 ,"----" ); // name of 1st linked atom strcpy ( aloc1 ," " ); // alternative location of 1st atom strcpy ( resName1,"---" ); // residue name of 1st linked atom strcpy ( chainID1," " ); // chain ID of 1st linked atom seqNum1 = 0; // sequence number of 1st linked atom strcpy ( insCode1," " ); // insertion code of 1st linked atom strcpy ( atName2 ,"----" ); // name of 2nd linked atom strcpy ( aloc2 ," " ); // alternative location of 2nd atom strcpy ( resName2,"---" ); // residue name of 2nd linked atom strcpy ( chainID2," " ); // chain ID of 2nd linked atom seqNum2 = 0; // sequence number of 2nd linked atom strcpy ( insCode2," " ); // insertion code of 2nd linked atom s1 = 1; // sym id of 1st atom i1 = 5; j1 = 5; k1 = 5; s2 = 1; // sym id of 2nd atom i2 = 5; j2 = 5; k2 = 5; } void CLink::PDBASCIIDump ( pstr S, int N ) { UNUSED_ARGUMENT(N); // makes the ASCII PDB OBSLTE line number N // from the class' data strcpy ( S,"LINK" ); PadSpaces ( S,80 ); strcpy_n1 ( &(S[12]),atName1 ,4 ); strcpy_n1 ( &(S[16]),aloc1 ,1 ); strcpy_n1 ( &(S[17]),resName1,3 ); strcpy_n1 ( &(S[21]),chainID1,1 ); PutIntIns ( &(S[22]),seqNum1 ,4,insCode1 ); strcpy_n1 ( &(S[42]),atName2 ,4 ); strcpy_n1 ( &(S[46]),aloc2 ,1 ); strcpy_n1 ( &(S[47]),resName2,3 ); strcpy_n1 ( &(S[51]),chainID2,1 ); PutIntIns ( &(S[52]),seqNum2 ,4,insCode2 ); PutInteger ( &(S[59]),s1,3 ); PutInteger ( &(S[62]),i1,1 ); PutInteger ( &(S[63]),j1,1 ); PutInteger ( &(S[64]),k1,1 ); PutInteger ( &(S[66]),s2,3 ); PutInteger ( &(S[69]),i2,1 ); PutInteger ( &(S[70]),j2,1 ); PutInteger ( &(S[71]),k2,1 ); } #define LinkTypeID "LINK" void AddStructConnTags ( PCMMCIFLoop Loop ) { Loop->AddLoopTag ( CIFTAG_ID ); Loop->AddLoopTag ( CIFTAG_CONN_TYPE_ID ); Loop->AddLoopTag ( CIFTAG_CONN_PTNR1_AUTH_ATOM_ID ); Loop->AddLoopTag ( CIFTAG_CONN_PDBX_PTNR1_AUTH_ALT_ID ); Loop->AddLoopTag ( CIFTAG_CONN_PTNR1_AUTH_COMP_ID ); Loop->AddLoopTag ( CIFTAG_CONN_PTNR1_AUTH_ASYM_ID ); Loop->AddLoopTag ( CIFTAG_CONN_PTNR1_AUTH_SEQ_ID ); Loop->AddLoopTag ( CIFTAG_CONN_PDBX_PTNR1_PDB_INS_CODE ); Loop->AddLoopTag ( CIFTAG_CONN_PTNR2_AUTH_ATOM_ID ); Loop->AddLoopTag ( CIFTAG_CONN_PDBX_PTNR2_AUTH_ALT_ID ); Loop->AddLoopTag ( CIFTAG_CONN_PTNR2_AUTH_COMP_ID ); Loop->AddLoopTag ( CIFTAG_CONN_PTNR2_AUTH_ASYM_ID ); Loop->AddLoopTag ( CIFTAG_CONN_PTNR2_AUTH_SEQ_ID ); Loop->AddLoopTag ( CIFTAG_CONN_PDBX_PTNR2_PDB_INS_CODE ); Loop->AddLoopTag ( CIFTAG_CONN_PTNR1_SYMMETRY ); Loop->AddLoopTag ( CIFTAG_CONN_PTNR2_SYMMETRY ); } void CLink::MakeCIF ( PCMMCIFData CIF, int N ) { UNUSED_ARGUMENT(N); PCMMCIFLoop Loop; char S[100]; int RC; RC = CIF->AddLoop ( CIFCAT_STRUCT_CONN,Loop ); if (RC!=CIFRC_Ok) // the category was (re)created, provide tags AddStructConnTags ( Loop ); Loop->AddString ( "1" ); // should be a counter Loop->AddString ( pstr(LinkTypeID) ); Loop->AddString ( atName1 ); Loop->AddString ( aloc1 ); Loop->AddString ( resName1 ); Loop->AddString ( chainID1 ); Loop->AddInteger ( seqNum1 ); Loop->AddString ( insCode1 ); Loop->AddString ( atName2 ); Loop->AddString ( aloc2 ); Loop->AddString ( resName2 ); Loop->AddString ( chainID2 ); Loop->AddInteger ( seqNum2 ); Loop->AddString ( insCode2 ); sprintf ( S,"%i%i%i%i",s1,i1,j1,k1 ); Loop->AddString ( S ); sprintf ( S,"%i%i%i%i",s2,i2,j2,k2 ); Loop->AddString ( S ); } int CLink::ConvertPDBASCII ( cpstr S ) { GetString ( atName1 ,&(S[12]),4 ); strcpy_ncss ( aloc1 ,&(S[16]),1 ); strcpy_ncss ( resName1,&(S[17]),3 ); strcpy_ncss ( chainID1,&(S[21]),1 ); GetIntIns ( seqNum1,insCode1,&(S[22]),4 ); GetString ( atName2 ,&(S[42]),4 ); strcpy_ncss ( aloc2 ,&(S[46]),1 ); strcpy_ncss ( resName2,&(S[47]),3 ); strcpy_ncss ( chainID2,&(S[51]),1 ); GetIntIns ( seqNum2,insCode2,&(S[52]),4 ); GetInteger ( s1,&(S[59]),3 ); GetInteger ( i1,&(S[62]),1 ); GetInteger ( j1,&(S[63]),1 ); GetInteger ( k1,&(S[64]),1 ); GetInteger ( s2,&(S[66]),3 ); GetInteger ( i2,&(S[69]),1 ); GetInteger ( j2,&(S[70]),1 ); GetInteger ( k2,&(S[71]),1 ); return 0; } void CLink::GetCIF ( PCMMCIFData CIF, int & Signal ) { PCMMCIFLoop Loop; pstr F; char S[100]; int RC,l; Boolean Done; Loop = CIF->GetLoop ( CIFCAT_STRUCT_CONN ); if (!Loop) { Signal = -1; // signal to finish processing of this structure return; } l = Loop->GetLoopLength(); Done = (Signal>=l); while (!Done) { F = Loop->GetString ( CIFTAG_CONN_TYPE_ID,Signal,RC ); if ((!RC) && F) Done = (strcmp(F,LinkTypeID)==0); else Done = False; if (!Done) { Signal++; Done = (Signal>=l); } } if (Signal>=l) { Signal = -1; // finish processing of Turn return; } Loop->DeleteField ( CIFTAG_CONN_TYPE_ID,Signal ); // CIFGetInteger ( l,Loop,CIFTAG_ID,Signal ); CIFGetString ( atName1,Loop,CIFTAG_CONN_PTNR1_AUTH_ATOM_ID,Signal, sizeof(atName1),pstr(" ") ); CIFGetString ( aloc1,Loop,CIFTAG_CONN_PDBX_PTNR1_AUTH_ALT_ID,Signal, sizeof(aloc1),pstr(" ") ); CIFGetString ( resName1,Loop,CIFTAG_CONN_PTNR1_AUTH_COMP_ID,Signal, sizeof(resName1),pstr(" ") ); CIFGetString ( chainID1,Loop,CIFTAG_CONN_PTNR1_AUTH_ASYM_ID,Signal, sizeof(chainID1),pstr(" ") ); if (CIFGetInteger(seqNum1,Loop,CIFTAG_CONN_PTNR1_AUTH_SEQ_ID,Signal)) return; CIFGetString ( insCode1,Loop,CIFTAG_CONN_PDBX_PTNR1_PDB_INS_CODE, Signal,sizeof(insCode1),pstr(" ") ); CIFGetString ( atName2,Loop,CIFTAG_CONN_PTNR2_AUTH_ATOM_ID,Signal, sizeof(atName2),pstr(" ") ); CIFGetString ( aloc2,Loop,CIFTAG_CONN_PDBX_PTNR2_AUTH_ALT_ID,Signal, sizeof(aloc2),pstr(" ") ); CIFGetString ( resName2,Loop,CIFTAG_CONN_PTNR2_AUTH_COMP_ID,Signal, sizeof(resName2),pstr(" ") ); CIFGetString ( chainID2,Loop,CIFTAG_CONN_PTNR2_AUTH_ASYM_ID,Signal, sizeof(chainID2),pstr(" ") ); if (CIFGetInteger(seqNum2,Loop,CIFTAG_CONN_PTNR2_AUTH_SEQ_ID,Signal)) return; CIFGetString ( insCode2,Loop,CIFTAG_CONN_PDBX_PTNR2_PDB_INS_CODE, Signal,sizeof(insCode2),pstr(" ") ); CIFGetString ( S,Loop,CIFTAG_CONN_PTNR1_SYMMETRY,Signal, sizeof(S),pstr("") ); if (S[0]) { l = strlen(S)-1; k1 = int(S[l--]) - int('0'); j1 = int(S[l--]) - int('0'); i1 = int(S[l--]) - int('0'); S[l] = char(0); s1 = atoi(S); } CIFGetString ( S,Loop,CIFTAG_CONN_PTNR2_SYMMETRY,Signal, sizeof(S),pstr("") ); if (S[0]) { l = strlen(S)-1; k2 = int(S[l--]) - int('0'); j2 = int(S[l--]) - int('0'); i2 = int(S[l--]) - int('0'); S[l] = char(0); s2 = atoi(S); } Signal++; } void CLink::Copy ( PCContainerClass Link ) { strcpy ( atName1 ,PCLink(Link)->atName1 ); strcpy ( aloc1 ,PCLink(Link)->aloc1 ); strcpy ( resName1,PCLink(Link)->resName1 ); strcpy ( chainID1,PCLink(Link)->chainID1 ); seqNum1 = PCLink(Link)->seqNum1; strcpy ( insCode1,PCLink(Link)->insCode1 ); strcpy ( atName2 ,PCLink(Link)->atName2 ); strcpy ( aloc2 ,PCLink(Link)->aloc2 ); strcpy ( resName2,PCLink(Link)->resName2 ); strcpy ( chainID2,PCLink(Link)->chainID2 ); seqNum2 = PCLink(Link)->seqNum2; strcpy ( insCode2,PCLink(Link)->insCode2 ); s1 = PCLink(Link)->s1; i1 = PCLink(Link)->i1; j1 = PCLink(Link)->j1; k1 = PCLink(Link)->k1; s2 = PCLink(Link)->s2; i2 = PCLink(Link)->i2; j2 = PCLink(Link)->j2; k2 = PCLink(Link)->k2; } void CLink::write ( RCFile f ) { byte Version=1; f.WriteByte ( &Version ); f.WriteTerLine ( atName1 ,False ); f.WriteTerLine ( aloc1 ,False ); f.WriteTerLine ( resName1,False ); f.WriteTerLine ( chainID1,False ); f.WriteInt ( &seqNum1 ); f.WriteTerLine ( insCode1,False ); f.WriteTerLine ( atName2 ,False ); f.WriteTerLine ( aloc2 ,False ); f.WriteTerLine ( resName2,False ); f.WriteTerLine ( chainID2,False ); f.WriteInt ( &seqNum2 ); f.WriteTerLine ( insCode2,False ); f.WriteInt ( &s1 ); f.WriteInt ( &i1 ); f.WriteInt ( &j1 ); f.WriteInt ( &k1 ); f.WriteInt ( &s2 ); f.WriteInt ( &i2 ); f.WriteInt ( &j2 ); f.WriteInt ( &k2 ); } void CLink::read ( RCFile f ) { byte Version; f.ReadByte ( &Version ); f.ReadTerLine ( atName1 ,False ); f.ReadTerLine ( aloc1 ,False ); f.ReadTerLine ( resName1,False ); f.ReadTerLine ( chainID1,False ); f.ReadInt ( &seqNum1 ); f.ReadTerLine ( insCode1,False ); f.ReadTerLine ( atName2 ,False ); f.ReadTerLine ( aloc2 ,False ); f.ReadTerLine ( resName2,False ); f.ReadTerLine ( chainID2,False ); f.ReadInt ( &seqNum2 ); f.ReadTerLine ( insCode2,False ); f.ReadInt ( &s1 ); f.ReadInt ( &i1 ); f.ReadInt ( &j1 ); f.ReadInt ( &k1 ); f.ReadInt ( &s2 ); f.ReadInt ( &i2 ); f.ReadInt ( &j2 ); f.ReadInt ( &k2 ); } MakeStreamFunctions(CLink) // =================== CLinkRContainer ======================= PCContainerClass CLinkRContainer::MakeContainerClass ( int ClassID ) { switch (ClassID) { default : case ClassID_Template : return CClassContainer::MakeContainerClass(ClassID); case ClassID_LinkR : return new CLinkR(); } } MakeStreamFunctions(CLinkRContainer) // ======================== CLinkR =========================== CLinkR::CLinkR() : CContainerClass() { InitLinkR(); } CLinkR::CLinkR ( cpstr S ) : CContainerClass() { InitLinkR(); ConvertPDBASCII ( S ); } CLinkR::CLinkR ( RPCStream Object ) : CContainerClass(Object) { InitLinkR(); } CLinkR::~CLinkR() {} void CLinkR::InitLinkR() { strcpy ( linkRID ,"----" ); // link name strcpy ( atName1 ,"----" ); // name of 1st linked atom strcpy ( aloc1 ," " ); // alternative location of 1st atom strcpy ( resName1,"---" ); // residue name of 1st linked atom strcpy ( chainID1," " ); // chain ID of 1st linked atom seqNum1 = 0; // sequence number of 1st linked atom strcpy ( insCode1," " ); // insertion code of 1st linked atom strcpy ( atName2 ,"----" ); // name of 2nd linked atom strcpy ( aloc2 ," " ); // alternative location of 2nd atom strcpy ( resName2,"---" ); // residue name of 2nd linked atom strcpy ( chainID2," " ); // chain ID of 2nd linked atom seqNum2 = 0; // sequence number of 2nd linked atom strcpy ( insCode2," " ); // insertion code of 2nd linked atom dist = 0.0; // link distance } /* LINK LYS A 27 PLP A 255 PLPLYS LINK MAN S 3 MAN S 4 BETA1-4 LINK C6 BBEN B 1 O1 BMAF S 2 BEN-MAF LINK OE2 AGLU A 320 C1 AMAF S 2 GLU-MAF LINK OE2 GLU A 67 1.895 ZN ZN R 5 GLU-ZN LINK NE2 HIS A 71 2.055 ZN ZN R 5 HIS-ZN LINK O ARG A 69 2.240 NA NA R 9 ARG-NA 012345678901234567890123456789012345678901234567890123456789012345678901234567890 1 2 3 4 5 6 7 */ void CLinkR::PDBASCIIDump ( pstr S, int N ) { UNUSED_ARGUMENT(N); // makes the ASCII PDB OBSLTE line number N // from the class' data strcpy ( S,"LINKR" ); PadSpaces ( S,80 ); strcpy_n1 ( &(S[12]),atName1 ,4 ); strcpy_n1 ( &(S[16]),aloc1 ,1 ); strcpy_n1 ( &(S[17]),resName1,3 ); strcpy_n1 ( &(S[21]),chainID1,1 ); PutIntIns ( &(S[22]),seqNum1 ,4,insCode1 ); if (dist>0.0) PutRealF ( &(S[32]),dist,7,3 ); strcpy_n1 ( &(S[42]),atName2 ,4 ); strcpy_n1 ( &(S[46]),aloc2 ,1 ); strcpy_n1 ( &(S[47]),resName2,3 ); strcpy_n1 ( &(S[51]),chainID2,1 ); PutIntIns ( &(S[52]),seqNum2 ,4,insCode2 ); strcpy_ns ( &(S[72]),linkRID,8 ); } #define LinkRTypeID "LINKR" void AddStructConnLinkRTags ( PCMMCIFLoop Loop ) { Loop->AddLoopTag ( CIFTAG_ID ); Loop->AddLoopTag ( CIFTAG_CONN_TYPE_ID ); Loop->AddLoopTag ( CIFTAG_CONN_PTNR1_AUTH_ATOM_ID ); Loop->AddLoopTag ( CIFTAG_CONN_PDBX_PTNR1_AUTH_ALT_ID ); Loop->AddLoopTag ( CIFTAG_CONN_PTNR1_AUTH_COMP_ID ); Loop->AddLoopTag ( CIFTAG_CONN_PTNR1_AUTH_ASYM_ID ); Loop->AddLoopTag ( CIFTAG_CONN_PTNR1_AUTH_SEQ_ID ); Loop->AddLoopTag ( CIFTAG_CONN_PDBX_PTNR1_PDB_INS_CODE ); Loop->AddLoopTag ( CIFTAG_CONN_DIST ); Loop->AddLoopTag ( CIFTAG_CONN_PTNR2_AUTH_ATOM_ID ); Loop->AddLoopTag ( CIFTAG_CONN_PDBX_PTNR2_AUTH_ALT_ID ); Loop->AddLoopTag ( CIFTAG_CONN_PTNR2_AUTH_COMP_ID ); Loop->AddLoopTag ( CIFTAG_CONN_PTNR2_AUTH_ASYM_ID ); Loop->AddLoopTag ( CIFTAG_CONN_PTNR2_AUTH_SEQ_ID ); Loop->AddLoopTag ( CIFTAG_CONN_PDBX_PTNR2_PDB_INS_CODE ); Loop->AddLoopTag ( CIFTAG_CONN_NAME ); } void CLinkR::MakeCIF ( PCMMCIFData CIF, int N ) { UNUSED_ARGUMENT(N); PCMMCIFLoop Loop; int RC; RC = CIF->AddLoop ( CIFCAT_STRUCT_LINKR,Loop ); if (RC!=CIFRC_Ok) // the category was (re)created, provide tags AddStructConnLinkRTags ( Loop ); Loop->AddString ( "1" ); // should be a counter Loop->AddString ( pstr(LinkTypeID) ); Loop->AddString ( atName1 ); Loop->AddString ( aloc1 ); Loop->AddString ( resName1 ); Loop->AddString ( chainID1 ); Loop->AddInteger ( seqNum1 ); Loop->AddString ( insCode1 ); Loop->AddReal ( dist ); Loop->AddString ( atName2 ); Loop->AddString ( aloc2 ); Loop->AddString ( resName2 ); Loop->AddString ( chainID2 ); Loop->AddInteger ( seqNum2 ); Loop->AddString ( insCode2 ); Loop->AddString ( linkRID ); } int CLinkR::ConvertPDBASCII ( cpstr S ) { GetString ( atName1 ,&(S[12]),4 ); strcpy_ncss ( aloc1 ,&(S[16]),1 ); strcpy_ncss ( resName1,&(S[17]),3 ); strcpy_ncss ( chainID1,&(S[21]),1 ); GetIntIns ( seqNum1,insCode1,&(S[22]),4 ); if (!GetReal(dist,&(S[32]),7)) dist = 0.0; GetString ( atName2 ,&(S[42]),4 ); strcpy_ncss ( aloc2 ,&(S[46]),1 ); strcpy_ncss ( resName2,&(S[47]),3 ); strcpy_ncss ( chainID2,&(S[51]),1 ); GetIntIns ( seqNum2,insCode2,&(S[52]),4 ); strcpy_ncss ( linkRID,&(S[72]),8 ); return 0; } void CLinkR::GetCIF ( PCMMCIFData CIF, int & Signal ) { PCMMCIFLoop Loop; pstr F; int RC,l; Boolean Done; Loop = CIF->GetLoop ( CIFCAT_STRUCT_CONN ); if (!Loop) { Signal = -1; // signal to finish processing of this structure return; } l = Loop->GetLoopLength(); Done = (Signal>=l); while (!Done) { F = Loop->GetString ( CIFTAG_CONN_TYPE_ID,Signal,RC ); if ((!RC) && F) Done = (strcmp(F,LinkTypeID)==0); else Done = False; if (!Done) { Signal++; Done = (Signal>=l); } } if (Signal>=l) { Signal = -1; // finish processing of Turn return; } Loop->DeleteField ( CIFTAG_CONN_TYPE_ID,Signal ); // CIFGetInteger ( l,Loop,CIFTAG_ID,Signal ); CIFGetString ( atName1,Loop,CIFTAG_CONN_PTNR1_AUTH_ATOM_ID,Signal, sizeof(atName1),pstr(" ") ); CIFGetString ( aloc1,Loop,CIFTAG_CONN_PDBX_PTNR1_AUTH_ALT_ID,Signal, sizeof(aloc1),pstr(" ") ); CIFGetString ( resName1,Loop,CIFTAG_CONN_PTNR1_AUTH_COMP_ID,Signal, sizeof(resName1),pstr(" ") ); CIFGetString ( chainID1,Loop,CIFTAG_CONN_PTNR1_AUTH_ASYM_ID,Signal, sizeof(chainID1),pstr(" ") ); if (CIFGetInteger(seqNum1,Loop,CIFTAG_CONN_PTNR1_AUTH_SEQ_ID,Signal)) return; CIFGetString ( insCode1,Loop,CIFTAG_CONN_PDBX_PTNR1_PDB_INS_CODE, Signal,sizeof(insCode1),pstr(" ") ); if (CIFGetReal(dist,Loop,CIFTAG_CONN_DIST,Signal)) return; CIFGetString ( atName2,Loop,CIFTAG_CONN_PTNR2_AUTH_ATOM_ID,Signal, sizeof(atName2),pstr(" ") ); CIFGetString ( aloc2,Loop,CIFTAG_CONN_PDBX_PTNR2_AUTH_ALT_ID,Signal, sizeof(aloc2),pstr(" ") ); CIFGetString ( resName2,Loop,CIFTAG_CONN_PTNR2_AUTH_COMP_ID,Signal, sizeof(resName2),pstr(" ") ); CIFGetString ( chainID2,Loop,CIFTAG_CONN_PTNR2_AUTH_ASYM_ID,Signal, sizeof(chainID2),pstr(" ") ); if (CIFGetInteger(seqNum2,Loop,CIFTAG_CONN_PTNR2_AUTH_SEQ_ID,Signal)) return; CIFGetString ( insCode2,Loop,CIFTAG_CONN_PDBX_PTNR2_PDB_INS_CODE, Signal,sizeof(insCode2),pstr(" ") ); CIFGetString ( linkRID,Loop,CIFTAG_CONN_NAME,Signal, sizeof(linkRID),pstr(" ") ); Signal++; } void CLinkR::Copy ( PCContainerClass LinkR ) { strcpy ( atName1 ,PCLinkR(LinkR)->atName1 ); strcpy ( aloc1 ,PCLinkR(LinkR)->aloc1 ); strcpy ( resName1,PCLinkR(LinkR)->resName1 ); strcpy ( chainID1,PCLinkR(LinkR)->chainID1 ); seqNum1 = PCLinkR(LinkR)->seqNum1; strcpy ( insCode1,PCLinkR(LinkR)->insCode1 ); dist = PCLinkR(LinkR)->dist; strcpy ( atName2 ,PCLinkR(LinkR)->atName2 ); strcpy ( aloc2 ,PCLinkR(LinkR)->aloc2 ); strcpy ( resName2,PCLinkR(LinkR)->resName2 ); strcpy ( chainID2,PCLinkR(LinkR)->chainID2 ); seqNum2 = PCLinkR(LinkR)->seqNum2; strcpy ( insCode2,PCLinkR(LinkR)->insCode2 ); strcpy ( linkRID,PCLinkR(LinkR)->linkRID ); } void CLinkR::write ( RCFile f ) { byte Version=1; f.WriteByte ( &Version ); f.WriteTerLine ( atName1 ,False ); f.WriteTerLine ( aloc1 ,False ); f.WriteTerLine ( resName1,False ); f.WriteTerLine ( chainID1,False ); f.WriteInt ( &seqNum1 ); f.WriteTerLine ( insCode1,False ); f.WriteReal ( &dist ); f.WriteTerLine ( atName2 ,False ); f.WriteTerLine ( aloc2 ,False ); f.WriteTerLine ( resName2,False ); f.WriteTerLine ( chainID2,False ); f.WriteInt ( &seqNum2 ); f.WriteTerLine ( insCode2,False ); f.WriteTerLine ( linkRID,False ); } void CLinkR::read ( RCFile f ) { byte Version; f.ReadByte ( &Version ); f.ReadTerLine ( atName1 ,False ); f.ReadTerLine ( aloc1 ,False ); f.ReadTerLine ( resName1,False ); f.ReadTerLine ( chainID1,False ); f.ReadInt ( &seqNum1 ); f.ReadTerLine ( insCode1,False ); f.ReadReal ( &dist ); f.ReadTerLine ( atName2 ,False ); f.ReadTerLine ( aloc2 ,False ); f.ReadTerLine ( resName2,False ); f.ReadTerLine ( chainID2,False ); f.ReadInt ( &seqNum2 ); f.ReadTerLine ( insCode2,False ); f.ReadTerLine ( linkRID,False ); } MakeStreamFunctions(CLinkR) // =================== CCisPepContainer ====================== PCContainerClass CCisPepContainer::MakeContainerClass ( int ClassID ) { switch (ClassID) { default : case ClassID_Template : return CClassContainer::MakeContainerClass(ClassID); case ClassID_CisPep : return new CCisPep(); } } MakeStreamFunctions(CCisPepContainer) // ======================== CCisPep ========================== CCisPep::CCisPep() : CContainerClass() { InitCisPep(); } CCisPep::CCisPep ( cpstr S ) : CContainerClass() { InitCisPep(); ConvertPDBASCII ( S ); } CCisPep::CCisPep ( RPCStream Object ) : CContainerClass(Object) { InitCisPep(); } CCisPep::~CCisPep() {} void CCisPep::InitCisPep() { serNum = 1; // record serial number strcpy ( pep1 ,"---" ); // residue name strcpy ( chainID1," " ); // chain identifier 1 seqNum1 = 0; // residue sequence number 1 strcpy ( icode1 ," " ); // insertion code 1 strcpy ( pep2 ,"---" ); // residue name 2 strcpy ( chainID2," " ); // chain identifier 2 seqNum2 = 0; // residue sequence number 2 strcpy ( icode2 ," " ); // insertion code 2 modNum = 0; // model number measure = 0.0; // measure of the angle in degrees. } void CCisPep::PDBASCIIDump ( pstr S, int N ) { UNUSED_ARGUMENT(N); strcpy ( S,"CISPEP" ); PadSpaces ( S,80 ); PutInteger ( &(S[7]),serNum,3 ); strcpy_n1 ( &(S[11]),pep1 ,3 ); strcpy_n1 ( &(S[15]),chainID1,1 ); PutIntIns ( &(S[17]),seqNum1 ,4,icode1 ); strcpy_n1 ( &(S[25]),pep2 ,3 ); strcpy_n1 ( &(S[29]),chainID2,1 ); PutIntIns ( &(S[31]),seqNum2 ,4,icode1 ); PutInteger ( &(S[43]),modNum,3 ); PutRealF ( &(S[53]),measure,6,2 ); } int CCisPep::ConvertPDBASCII ( cpstr S ) { GetInteger ( serNum ,&(S[7]) ,3 ); strcpy_ncss ( pep1 ,&(S[11]),3 ); strcpy_ncss ( chainID1,&(S[15]),1 ); GetIntIns ( seqNum1,icode1,&(S[17]),4 ); strcpy_ncss ( pep2 ,&(S[25]),3 ); strcpy_ncss ( chainID2,&(S[29]),1 ); GetIntIns ( seqNum2,icode2,&(S[31]),4 ); GetInteger ( modNum ,&(S[43]),3 ); GetReal ( measure ,&(S[53]),6 ); return 0; } void CCisPep::Copy ( PCContainerClass CisPep ) { serNum = PCCisPep(CisPep)->serNum; strcpy ( pep1 ,PCCisPep(CisPep)->pep1 ); strcpy ( chainID1,PCCisPep(CisPep)->chainID1 ); seqNum1 = PCCisPep(CisPep)->seqNum1; strcpy ( icode1 ,PCCisPep(CisPep)->icode1 ); strcpy ( pep2 ,PCCisPep(CisPep)->pep2 ); strcpy ( chainID2,PCCisPep(CisPep)->chainID2 ); seqNum2 = PCCisPep(CisPep)->seqNum2; strcpy ( icode2 ,PCCisPep(CisPep)->icode2 ); modNum = PCCisPep(CisPep)->modNum; measure = PCCisPep(CisPep)->measure; } void CCisPep::write ( RCFile f ) { byte Version=1; f.WriteByte ( &Version ); f.WriteInt ( &serNum ); f.WriteTerLine ( pep1 ,False ); f.WriteTerLine ( chainID1,False ); f.WriteInt ( &seqNum1 ); f.WriteTerLine ( icode1 ,False ); f.WriteTerLine ( pep2 ,False ); f.WriteTerLine ( chainID2,False ); f.WriteInt ( &seqNum2 ); f.WriteTerLine ( icode2 ,False ); f.WriteInt ( &modNum ); f.WriteReal ( &measure ); } void CCisPep::read ( RCFile f ) { byte Version; f.ReadByte ( &Version ); f.ReadInt ( &serNum ); f.ReadTerLine ( pep1 ,False ); f.ReadTerLine ( chainID1,False ); f.ReadInt ( &seqNum1 ); f.ReadTerLine ( icode1 ,False ); f.ReadTerLine ( pep2 ,False ); f.ReadTerLine ( chainID2,False ); f.ReadInt ( &seqNum2 ); f.ReadTerLine ( icode2 ,False ); f.ReadInt ( &modNum ); f.ReadReal ( &measure ); } MakeStreamFunctions(CCisPep) // ===================== CModel ======================= CModel::CModel() : CProModel() { InitModel(); } CModel::CModel ( PCMMDBManager MMDBM, int serialNum ) : CProModel() { InitModel(); manager = MMDBM; serNum = serialNum; } CModel::CModel ( RPCStream Object ) : CProModel(Object) { InitModel(); } void CModel::InitModel() { serNum = 0; nChains = 0; nChainsAlloc = 0; Chain = NULL; manager = NULL; Exclude = True; } CModel::~CModel() { FreeMemory(); if (manager) manager->_ExcludeModel ( serNum ); } void CModel::FreeMemory() { DeleteAllChains(); if (Chain) delete[] Chain; Chain = NULL; nChains = 0; nChainsAlloc = 0; RemoveSecStructure(); RemoveHetInfo (); RemoveLinks (); RemoveLinkRs (); RemoveCisPeps (); } void CModel::SetMMDBManager ( PCMMDBManager MMDBM, int serialNum ) { manager = MMDBM; serNum = serialNum; } void CModel::CheckInAtoms() { int i; if (manager) for (i=0;iCheckInAtoms(); } int CModel::GetNumberOfAtoms ( Boolean countTers ) { // returns number of atoms in the model int i,na; na = 0; for (i=0;iGetNumberOfAtoms ( countTers ); return na; } int CModel::GetNumberOfResidues() { // returns number of residues in the model PCChain chain; int ic,ir,nr; nr = 0; for (ic=0;icnResidues;ir++) if (chain->Residue[ir]) nr++; } return nr; } // ---------------- Extracting chains -------------------------- int CModel::GetNumberOfChains() { return nChains; } PCChain CModel::GetChain ( int chainNo ) { if ((0<=chainNo) && (chainNo=nChainsAlloc) { nChainsAlloc = nOfChains+10; Chain1 = new PCChain[nChainsAlloc]; for (i=0;ichainID[0]) { chain = Chain[i]; if (chain->GetNumberOfResidues()>0) k++; } } if (k) sprintf ( chainID,"%s%i",chID,k-1 ); else if (!chain) strcpy ( chainID,chID ); // chain is absent else return chain; // the only empty chain } else { if (chID[0]) { for (i=0;(ichainID)) chain = Chain[i]; // it is there; just return the pointer } } else { for (i=0;(ichainID[0]) chain = Chain[i]; // it is there; just return the pointer } } if (chain) return chain; strcpy ( chainID,chID ); } ExpandChainArray ( nChains ); // create new chain Chain[nChains] = newCChain(); Chain[nChains]->SetChain ( chainID ); Chain[nChains]->SetModel ( this ); nChains++; return Chain[nChains-1]; } PCChain CModel::CreateChain ( const ChainID chID ) { // CreateChain() creates a new chain with chain ID regardless // the presence of same-ID chains in the model. This function // was introduced only for compatibility with older CCP4 // applications and using it in any new developments should be // strictly discouraged. ExpandChainArray ( nChains ); // create new chain Chain[nChains] = newCChain(); Chain[nChains]->SetChain ( chID ); Chain[nChains]->SetModel ( this ); nChains++; return Chain[nChains-1]; } void CModel::GetChainTable ( PPCChain & chainTable, int & NumberOfChains ) { chainTable = Chain; NumberOfChains = nChains; } Boolean CModel::GetNewChainID ( ChainID chID, int length ) { int i,k; Boolean found; memset ( chID,0,sizeof(ChainID) ); chID[0] = 'A'; do { found = False; for (i=0;(ichainID)); if (found) { k = 0; while (kchainID)) return Chain[i]; // it is there; just return the pointer } } else { for (i=0;ichainID[0]) return Chain[i]; // it is there; just return the pointer } } return NULL; } // ------------------ Deleting chains -------------------------- int CModel::DeleteChain ( int chainNo ) { if ((0<=chainNo) && (chainNochainID)) { Exclude = False; delete Chain[i]; Chain[i] = NULL; Exclude = True; return 1; } } } else { for (i=0;ichainID[0]) { Exclude = False; delete Chain[i]; Chain[i] = NULL; Exclude = True; return 1; } } } return 0; } int CModel::DeleteAllChains() { int i,k; Exclude = False; k = 0; for (i=0;iisSolventChain()) { delete Chain[i]; Chain[i] = NULL; k++; } } Exclude = True; return k; } void CModel::TrimChainTable() { int i,j; Exclude = False; j = 0; for (i=0;inResidues>0) { if (jnResidues; return 0; } int CModel::GetNumberOfResidues ( int chainNo ) { if ((0<=chainNo) && (chainNonResidues; } return 0; } PCResidue CModel::GetResidue ( const ChainID chainID, int seqNo, const InsCode insCode ) { PCChain chain; chain = GetChain ( chainID ); if (chain) return chain->GetResidue ( seqNo,insCode ); return NULL; } PCResidue CModel::GetResidue ( const ChainID chainID, int resNo ) { PCChain chain; chain = GetChain ( chainID ); if (chain) { if ((0<=resNo) && (resNonResidues)) return chain->Residue[resNo]; } return NULL; } PCResidue CModel::GetResidue ( int chainNo, int seqNo, const InsCode insCode ) { if ((0<=chainNo) && (chainNoGetResidue ( seqNo,insCode ); } return NULL; } PCResidue CModel::GetResidue ( int chainNo, int resNo ) { if ((0<=chainNo) && (chainNonResidues)) return Chain[chainNo]->Residue[resNo]; } } return NULL; } int CModel::GetResidueNo ( const ChainID chainID, int seqNo, const InsCode insCode ) { PCChain chain; chain = GetChain ( chainID ); if (chain) return chain->GetResidueNo ( seqNo,insCode ); return -2; } int CModel::GetResidueNo ( int chainNo, int seqNo, const InsCode insCode ) { if ((0<=chainNo) && (chainNoGetResidueNo ( seqNo,insCode ); } return -2; } void CModel::GetResidueTable ( PPCResidue & resTable, int & NumberOfResidues ) { // resTable has to be NULL or it will be reallocated. The application // is responsible for deallocating the resTable (but not of its // residues!). This does not apply to other GetResidueTable // functions. PPCChain chain; PPCResidue res; int i,j,k,nChns,nResidues; if (resTable) { delete[] resTable; resTable = NULL; } NumberOfResidues = 0; GetChainTable ( chain,nChns ); for (i=0;iGetResidueTable ( res,nResidues ); NumberOfResidues += nResidues; } if (NumberOfResidues>0) { resTable = new PCResidue[NumberOfResidues]; k = 0; GetChainTable ( chain,nChns ); for (i=0;iGetResidueTable ( res,nResidues ); for (j=0;jResidue; NumberOfResidues = chain->nResidues; } } void CModel::GetResidueTable ( int chainNo, PPCResidue & resTable, int & NumberOfResidues ) { resTable = NULL; NumberOfResidues = 0; if ((0<=chainNo) && (chainNoResidue; NumberOfResidues = Chain[chainNo]->nResidues; } } } int CModel::DeleteResidue ( const ChainID chainID, int seqNo, const InsCode insCode ) { PCChain chain; chain = GetChain ( chainID ); if (chain) return chain->DeleteResidue ( seqNo,insCode ); return 0; } int CModel::DeleteResidue ( const ChainID chainID, int resNo ) { PCChain chain; chain = GetChain ( chainID ); if (chain) return chain->DeleteResidue ( resNo ); return 0; } int CModel::DeleteResidue ( int chainNo, int seqNo, const InsCode insCode ) { if ((0<=chainNo) && (chainNoDeleteResidue ( seqNo,insCode ); } return 0; } int CModel::DeleteResidue ( int chainNo, int resNo ) { if ((0<=chainNo) && (chainNoDeleteResidue ( resNo ); } return 0; } int CModel::DeleteAllResidues ( const ChainID chainID ) { PCChain chain; chain = GetChain ( chainID ); if (chain) return chain->DeleteAllResidues(); return 0; } int CModel::DeleteAllResidues ( int chainNo ) { if ((0<=chainNo) && (chainNoDeleteAllResidues(); } return 0; } int CModel::DeleteAllResidues() { int i,k; k = 0; for (i=0;iDeleteAllResidues(); return k; } int CModel::DeleteSolvent() { int i,k; Exclude = False; k = 0; for (i=0;iDeleteSolvent(); Chain[i]->TrimResidueTable(); if (Chain[i]->nResidues<=0) { delete Chain[i]; Chain[i] = NULL; } } Exclude = True; return k; } int CModel::AddResidue ( const ChainID chainID, PCResidue res ) { PCChain chain; chain = GetChain ( chainID ); if (chain) return chain->AddResidue ( res ); return 0; } int CModel::AddResidue ( int chainNo, PCResidue res ) { if ((0<=chainNo) && (chainNoAddResidue ( res ); } return 0; } int CModel::_ExcludeChain ( const ChainID chainID ) { // _ExcludeChain(..) excludes (but does not dispose!) a chain // from the model. Returns 1 if the model gets empty and 0 otherwise. int i,k; if (!Exclude) return 0; // find the chain k = -1; for (i=0;(ichainID)) k = i; if (k>=0) { for (i=k+1;iGetChainID(), (PPCChain(data))[j]->GetChainID() ); if (diff>0) diff = 1; if (diff<0) diff = -1; if (sKey==SORT_CHAIN_ChainID_Desc) return -diff; return diff; } void CSortChains::Swap ( int i, int j ) { PCChain chn; chn = ((PPCChain)data)[i]; ((PPCChain)data)[i] = ((PPCChain)data)[j]; ((PPCChain)data)[j] = chn; } void CSortChains::Sort ( PPCChain chain, int nChains, int sortKey ) { sKey = sortKey; CQuickSort::Sort ( &(chain[0]),nChains ); } void CModel::SortChains ( int sortKey ) { CSortChains SC; TrimChainTable(); SC.Sort ( Chain,nChains,sortKey ); } // -------------------- Extracting atoms ----------------------- int CModel::GetNumberOfAtoms ( const ChainID chainID, int seqNo, const InsCode insCode ) { PCChain chain; PCResidue res; chain = GetChain ( chainID ); if (chain) { res = chain->GetResidue ( seqNo,insCode ); if (res) return res->nAtoms; } return 0; } int CModel::GetNumberOfAtoms ( int chainNo, int seqNo, const InsCode insCode ) { PCChain chain; PCResidue res; chain = GetChain ( chainNo ); if (chain) { res = chain->GetResidue ( seqNo,insCode ); if (res) return res->nAtoms; } return 0; } int CModel::GetNumberOfAtoms ( const ChainID chainID, int resNo ) { PCChain chain; PCResidue res; chain = GetChain ( chainID ); if (chain) { if ((0<=resNo) && (resNonResidues)) { res = chain->Residue[resNo]; if (res) return res->nAtoms; } } return 0; } int CModel::GetNumberOfAtoms ( int chainNo, int resNo ) { PCChain chain; PCResidue res; if ((0<=chainNo) && (chainNonResidues)) { res = chain->Residue[resNo]; if (res) return res->nAtoms; } } } return 0; } PCAtom CModel::GetAtom ( const ChainID chID, int seqNo, const InsCode insCode, const AtomName aname, const Element elmnt, const AltLoc aloc ) { PCChain chn; PCResidue res; chn = GetChain ( chID ); if (chn) { res = chn->GetResidue ( seqNo,insCode ); if (res) return res->GetAtom ( aname,elmnt,aloc ); } return NULL; } PCAtom CModel::GetAtom ( const ChainID chID, int seqNo, const InsCode insCode, int atomNo ) { PCChain chn; PCResidue res; chn = GetChain ( chID ); if (chn) { res = chn->GetResidue ( seqNo,insCode ); if (res) { if ((0<=atomNo) && (atomNonAtoms)) return res->atom[atomNo]; } } return NULL; } PCAtom CModel::GetAtom ( const ChainID chID, int resNo, const AtomName aname, const Element elmnt, const AltLoc aloc ) { PCChain chn; PCResidue res; chn = GetChain ( chID ); if (chn) { if ((0<=resNo) && (resNonResidues)) { res = chn->Residue[resNo]; if (res) return res->GetAtom ( aname,elmnt,aloc ); } } return NULL; } PCAtom CModel::GetAtom ( const ChainID chID, int resNo, int atomNo ) { PCChain chn; PCResidue res; chn = GetChain ( chID ); if (chn) { if ((0<=resNo) && (resNonResidues)) { res = chn->Residue[resNo]; if (res) { if ((0<=atomNo) && (atomNonAtoms)) return res->atom[atomNo]; } } } return NULL; } PCAtom CModel::GetAtom ( int chNo, int seqNo, const InsCode insCode, const AtomName aname, const Element elmnt, const AltLoc aloc ) { PCResidue res; if ((0<=chNo) && (chNoGetResidue ( seqNo,insCode ); if (res) return res->GetAtom ( aname,elmnt,aloc ); } } return NULL; } PCAtom CModel::GetAtom ( int chNo, int seqNo, const InsCode insCode, int atomNo ) { PCResidue res; if ((0<=chNo) && (chNoGetResidue ( seqNo,insCode ); if (res) { if ((0<=atomNo) && (atomNonAtoms)) return res->atom[atomNo]; } } } return NULL; } PCAtom CModel::GetAtom ( int chNo, int resNo, const AtomName aname, const Element elmnt, const AltLoc aloc ) { PCResidue res; if ((0<=chNo) && (chNonResidues)) { res = Chain[chNo]->Residue[resNo]; if (res) return res->GetAtom ( aname,elmnt,aloc ); } } } return NULL; } PCAtom CModel::GetAtom ( int chNo, int resNo, int atomNo ) { PCResidue res; if ((0<=chNo) && (chNonResidues)) { res = Chain[chNo]->Residue[resNo]; if (res) { if ((0<=atomNo) && (atomNonAtoms)) return res->atom[atomNo]; } } } } return NULL; } void CModel::GetAtomTable ( const ChainID chainID, int seqNo, const InsCode insCode, PPCAtom & atomTable, int & NumberOfAtoms ) { PCResidue res; atomTable = NULL; NumberOfAtoms = 0; res = GetResidue ( chainID,seqNo,insCode ); if (res) { atomTable = res->atom; NumberOfAtoms = res->nAtoms; } } void CModel::GetAtomTable ( int chainNo, int seqNo, const InsCode insCode, PPCAtom & atomTable, int & NumberOfAtoms ) { PCResidue res; atomTable = NULL; NumberOfAtoms = 0; res = GetResidue ( chainNo,seqNo,insCode ); if (res) { atomTable = res->atom; NumberOfAtoms = res->nAtoms; } } void CModel::GetAtomTable ( const ChainID chainID, int resNo, PPCAtom & atomTable, int & NumberOfAtoms ) { PCResidue res; atomTable = NULL; NumberOfAtoms = 0; res = GetResidue ( chainID,resNo ); if (res) { atomTable = res->atom; NumberOfAtoms = res->nAtoms; } } void CModel::GetAtomTable ( int chainNo, int resNo, PPCAtom & atomTable, int & NumberOfAtoms ) { PCResidue res; atomTable = NULL; NumberOfAtoms = 0; res = GetResidue ( chainNo,resNo ); if (res) { atomTable = res->atom; NumberOfAtoms = res->nAtoms; } } void CModel::GetAtomTable1 ( const ChainID chainID, int seqNo, const InsCode insCode, PPCAtom & atomTable, int & NumberOfAtoms ) { PCResidue res; res = GetResidue ( chainID,seqNo,insCode ); if (res) res->GetAtomTable1 ( atomTable,NumberOfAtoms ); else { if (atomTable) delete[] atomTable; atomTable = NULL; NumberOfAtoms = 0; } } void CModel::GetAtomTable1 ( int chainNo, int seqNo, const InsCode insCode, PPCAtom & atomTable, int & NumberOfAtoms ) { PCResidue res; res = GetResidue ( chainNo,seqNo,insCode ); if (res) res->GetAtomTable1 ( atomTable,NumberOfAtoms ); else { if (atomTable) delete[] atomTable; atomTable = NULL; NumberOfAtoms = 0; } } void CModel::GetAtomTable1 ( const ChainID chainID, int resNo, PPCAtom & atomTable, int & NumberOfAtoms ) { PCResidue res; res = GetResidue ( chainID,resNo ); if (res) res->GetAtomTable1 ( atomTable,NumberOfAtoms ); else { if (atomTable) delete[] atomTable; atomTable = NULL; NumberOfAtoms = 0; } } void CModel::GetAtomTable1 ( int chainNo, int resNo, PPCAtom & atomTable, int & NumberOfAtoms ) { PCResidue res; res = GetResidue ( chainNo,resNo ); if (res) res->GetAtomTable1 ( atomTable,NumberOfAtoms ); else { if (atomTable) delete[] atomTable; atomTable = NULL; NumberOfAtoms = 0; } } int CModel::DeleteAtom ( const ChainID chID, int seqNo, const InsCode insCode, const AtomName aname, const Element elmnt, const AltLoc aloc ) { PCChain chn; chn = GetChain ( chID ); if (chn) return chn->DeleteAtom ( seqNo,insCode,aname,elmnt,aloc ); return 0; } int CModel::DeleteAtom ( const ChainID chID, int seqNo, const InsCode insCode, int atomNo ) { PCChain chn; chn = GetChain ( chID ); if (chn) return chn->DeleteAtom ( seqNo,insCode,atomNo ); return 0; } int CModel::DeleteAtom ( const ChainID chID, int resNo, const AtomName aname, const Element elmnt, const AltLoc aloc ) { PCChain chn; chn = GetChain ( chID ); if (chn) return chn->DeleteAtom ( resNo,aname,elmnt,aloc ); return 0; } int CModel::DeleteAtom ( const ChainID chID, int resNo, int atomNo ) { PCChain chn; chn = GetChain ( chID ); if (chn) return chn->DeleteAtom ( resNo,atomNo ); return 0; } int CModel::DeleteAtom ( int chNo, int seqNo, const InsCode insCode, const AtomName aname, const Element elmnt, const AltLoc aloc ) { if ((0<=chNo) && (chNoDeleteAtom ( seqNo,insCode,aname, elmnt,aloc ); } return 0; } int CModel::DeleteAtom ( int chNo, int seqNo, const InsCode insCode, int atomNo ) { if ((0<=chNo) && (chNoDeleteAtom ( seqNo,insCode,atomNo ); } return 0; } int CModel::DeleteAtom ( int chNo, int resNo, const AtomName aname, const Element elmnt, const AltLoc aloc ) { if ((0<=chNo) && (chNoDeleteAtom ( resNo,aname,elmnt,aloc ); } return 0; } int CModel::DeleteAtom ( int chNo, int resNo, int atomNo ) { if ((0<=chNo) && (chNoDeleteAtom ( resNo,atomNo ); } return 0; } int CModel::DeleteAllAtoms ( const ChainID chID, int seqNo, const InsCode insCode ) { PCChain chn; chn = GetChain ( chID ); if (chn) return chn->DeleteAllAtoms ( seqNo,insCode ); return 0; } int CModel::DeleteAllAtoms ( const ChainID chID, int resNo ) { PCChain chn; chn = GetChain ( chID ); if (chn) return chn->DeleteAllAtoms ( resNo ); return 0; } int CModel::DeleteAllAtoms ( const ChainID chID ) { PCChain chn; chn = GetChain ( chID ); if (chn) return chn->DeleteAllAtoms(); return 0; } int CModel::DeleteAllAtoms ( int chNo, int seqNo, const InsCode insCode ) { if ((0<=chNo) && (chNoDeleteAllAtoms ( seqNo,insCode ); } return 0; } int CModel::DeleteAllAtoms ( int chNo, int resNo ) { if ((0<=chNo) && (chNoDeleteAllAtoms ( resNo ); } return 0; } int CModel::DeleteAllAtoms ( int chNo ) { if ((0<=chNo) && (chNoDeleteAllAtoms(); } return 0; } int CModel::DeleteAllAtoms() { int i,k; k = 0; for (i=0;iDeleteAllAtoms(); return k; } int CModel::DeleteAltLocs() { // This function leaves only alternative location with maximal // occupancy, if those are equal or unspecified, the one with // "least" alternative location indicator. // The function returns the number of deleted. All tables remain // untrimmed, so that explicit trimming or calling FinishStructEdit() // is required. int i,n; n = 0; for (i=0;iDeleteAltLocs(); return n; } int CModel::AddAtom ( const ChainID chID, int seqNo, const InsCode insCode, PCAtom atom ) { PCChain chn; chn = GetChain ( chID ); if (chn) return chn->AddAtom ( seqNo,insCode,atom ); return 0; } int CModel::AddAtom ( const ChainID chID, int resNo, PCAtom atom ) { PCChain chn; chn = GetChain ( chID ); if (chn) return chn->AddAtom ( resNo,atom ); return 0; } int CModel::AddAtom ( int chNo, int seqNo, const InsCode insCode, PCAtom atom ) { if ((0<=chNo) && (chNoAddAtom ( seqNo,insCode,atom ); } return 0; } int CModel::AddAtom ( int chNo, int resNo, PCAtom atom ) { if ((0<=chNo) && (chNoAddAtom ( resNo,atom ); } return 0; } void CModel::GetAtomStatistics ( RSAtomStat AS ) { AS.Init(); CalcAtomStatistics ( AS ); AS.Finish(); } void CModel::CalcAtomStatistics ( RSAtomStat AS ) { int i; for (i=0;iCalcAtomStatistics ( AS ); } int CModel::ConvertPDBString ( pstr PDBString ) { // Interprets PDB records DBREF, SEQADV, SEQRES, MODRES. // Returns zero if the line was converted, otherwise returns a // non-negative value of Error_XXXX. // PDBString must be not shorter than 81 characters. ChainID chainID; PCChain chain; PCHelix helix; PCTurn turn; PCLink link; PCLinkR linkR; PCCisPep cispep; int RC; // pad input line with spaces, if necessary PadSpaces ( PDBString,80 ); chainID[0] = char(0); chainID[1] = char(0); if (!strncmp(PDBString,"DBREF ",6)) { if (PDBString[12]!=' ') chainID[0] = PDBString[12]; chain = GetChainCreate ( chainID,False ); return chain->ConvertDBREF ( PDBString ); } else if (!strncmp(PDBString,"SEQADV",6)) { if (PDBString[16]!=' ') chainID[0] = PDBString[16]; chain = GetChainCreate ( chainID,False ); return chain->ConvertSEQADV ( PDBString ); } else if (!strncmp(PDBString,"SEQRES",6)) { if (PDBString[11]!=' ') chainID[0] = PDBString[11]; chain = GetChainCreate ( chainID,False ); return chain->ConvertSEQRES ( PDBString ); } else if (!strncmp(PDBString,"MODRES",6)) { if (PDBString[16]!=' ') chainID[0] = PDBString[16]; chain = GetChainCreate ( chainID,False ); return chain->ConvertMODRES ( PDBString ); } else if (!strncmp(PDBString,"HET ",6)) { if (PDBString[12]!=' ') chainID[0] = PDBString[12]; chain = GetChainCreate ( chainID,False ); return chain->ConvertHET ( PDBString ); } else if (!strncmp(PDBString,"HETNAM",6)) { HetCompounds.ConvertHETNAM ( PDBString ); return 0; } else if (!strncmp(PDBString,"HETSYN",6)) { HetCompounds.ConvertHETSYN ( PDBString ); return 0; } else if (!strncmp(PDBString,"FORMUL",6)) { HetCompounds.ConvertFORMUL ( PDBString ); return 0; } else if (!strncmp(PDBString,"HELIX ",6)) { helix = new CHelix(); RC = helix->ConvertPDBASCII(PDBString); if (RC==0) Helices.AddData ( helix ); else delete helix; return RC; } else if (!strncmp(PDBString,"SHEET ",6)) { return Sheets.ConvertPDBASCII ( PDBString ); } else if (!strncmp(PDBString,"TURN ",6)) { turn = new CTurn(); RC = turn->ConvertPDBASCII(PDBString); if (RC==0) Turns.AddData ( turn ); else delete turn; return RC; } else if (!strncmp(PDBString,"LINK ",6)) { link = new CLink(); RC = link->ConvertPDBASCII(PDBString); if (RC==0) Links.AddData ( link ); else delete link; return RC; } else if (!strncmp(PDBString,"LINKR ",6)) { linkR = new CLinkR(); RC = linkR->ConvertPDBASCII(PDBString); if (RC==0) LinkRs.AddData ( linkR ); else delete linkR; return RC; } else if (!strncmp(PDBString,"CISPEP",6)) { cispep = new CCisPep(); RC = cispep->ConvertPDBASCII(PDBString); if (RC==0) CisPeps.AddData ( cispep ); else delete cispep; return RC; } else return Error_WrongSection; } void CModel::PDBASCIIDumpPS ( RCFile f ) { int i; for (i=0;iDBReference.PDBASCIIDump ( f ); for (i=0;iSeqAdv.PDBASCIIDump ( f ); for (i=0;iSeqRes.PDBASCIIDump ( f ); for (i=0;iModRes.PDBASCIIDump ( f ); for (i=0;iHet.PDBASCIIDump ( f ); HetCompounds.PDBASCIIDump ( f ); Helices .PDBASCIIDump ( f ); Sheets .PDBASCIIDump ( f ); Turns .PDBASCIIDump ( f ); Links .PDBASCIIDump ( f ); LinkRs .PDBASCIIDump ( f ); } void CModel::PDBASCIIDumpCP ( RCFile f ) { CisPeps.PDBASCIIDump ( f ); } void CModel::PDBASCIIDump ( RCFile f ) { char S[100]; int i; Boolean singleModel = True; if (manager) singleModel = (manager->nModels<=1); if (!singleModel) { strcpy ( S,"MODEL " ); PadSpaces ( S,80 ); PutInteger ( &(S[10]),serNum,4 ); f.WriteLine ( S ); } for (i=0;iPDBASCIIAtomDump ( f ); if (!singleModel) { strcpy ( S,"ENDMDL" ); PadSpaces ( S,80 ); f.WriteLine ( S ); } } void CModel::MakeAtomCIF ( PCMMCIFData CIF ) { int i; for (i=0;iMakeAtomCIF ( CIF ); } void CModel::MakePSCIF ( PCMMCIFData CIF ) { int i; for (i=0;iDBReference.MakeCIF ( CIF ); for (i=0;iSeqAdv.MakeCIF ( CIF ); for (i=0;iSeqRes.MakeCIF ( CIF ); for (i=0;iModRes.MakeCIF ( CIF ); for (i=0;iHet.MakeCIF ( CIF ); HetCompounds.MakeCIF ( CIF ); Helices .MakeCIF ( CIF ); Sheets .MakeCIF ( CIF ); Turns .MakeCIF ( CIF ); Links .MakeCIF ( CIF ); LinkRs .MakeCIF ( CIF ); } int CModel::GetCIFPSClass ( PCMMCIFData CIF, int ClassID ) { CChainContainer PSClass; PCChainContainer Dest; int RC; cpstr chainID; PCChain chain; PSClass.SetChain ( NULL ); RC = PSClass.GetCIF ( CIF,ClassID ); if (RC) return RC; chainID = PSClass.Get1stChainID(); while (chainID) { chain = GetChainCreate ( chainID,False ); switch (ClassID) { case ClassID_DBReference : Dest = &(chain->DBReference); break; case ClassID_SeqAdv : Dest = &(chain->SeqAdv); break; case ClassID_ModRes : Dest = &(chain->ModRes); break; case ClassID_Het : Dest = &(chain->Het); break; default : Dest = NULL; } if (Dest) { PSClass.MoveByChainID ( chainID,Dest ); Dest->SetChain ( chain ); } else printf ( " **** PROGRAM ERROR: wrong call to" " CModel::GetCIFPSClass(..)\n" ); chainID = PSClass.Get1stChainID(); } return 0; } int CModel::GetCIF ( PCMMCIFData CIF ) { CSeqRes SeqRes; int RC; PCChain chain; RC = GetCIFPSClass ( CIF,ClassID_DBReference ); if (RC) return RC; RC = GetCIFPSClass ( CIF,ClassID_SeqAdv ); if (RC) return RC; RC = SeqRes.GetCIF ( CIF ); while (!RC) { chain = GetChainCreate ( SeqRes.chainID,False ); chain->SeqRes.Copy ( &SeqRes ); RC = SeqRes.GetCIF ( CIF ); } RC = GetCIFPSClass ( CIF,ClassID_ModRes ); if (RC) return RC; RC = GetCIFPSClass ( CIF,ClassID_Het ); if (RC) return RC; HetCompounds.GetCIF ( CIF ); Helices .GetCIF ( CIF,ClassID_Helix ); Sheets .GetCIF ( CIF ); Turns .GetCIF ( CIF,ClassID_Turn ); Links .GetCIF ( CIF,ClassID_Link ); LinkRs .GetCIF ( CIF,ClassID_LinkR ); return RC; } cpstr CModel::GetEntryID() { if (manager) return manager->Title.idCode; else return pstr(""); } void CModel::SetEntryID ( const IDCode idCode ) { if (manager) manager->SetEntryID ( idCode ); } int CModel::GetNumberOfAllAtoms() { if (manager) return manager->nAtoms; else return 0; } int CModel::GetSerNum() { return serNum; } PCAtom * CModel::GetAllAtoms() { if (manager) return manager->Atom; else return NULL; } cpstr CModel::GetModelID ( pstr modelID ) { modelID[0] = char(0); sprintf ( modelID,"/%i",serNum ); return modelID; } int CModel::GetNumberOfModels() { if (manager) return manager->nModels; else return 0; } void CModel::Copy ( PCModel Model ) { // modify both CModel::_copy and CModel::Copy methods simultaneously! int i; FreeMemory(); if (Model) { serNum = Model->serNum; nChains = Model->nChains; nChainsAlloc = nChains; if (nChains>0) { Chain = new PCChain[nChainsAlloc]; for (i=0;iChain[i]) { Chain[i] = newCChain(); Chain[i]->SetModel ( this ); Chain[i]->Copy ( Model->Chain[i] ); } else Chain[i] = NULL; } } HetCompounds.Copy ( &(Model->HetCompounds) ); Helices .Copy ( &(Model->Helices) ); Sheets .Copy ( &(Model->Sheets) ); Turns .Copy ( &(Model->Turns) ); Links .Copy ( &(Model->Links) ); LinkRs .Copy ( &(Model->LinkRs) ); CisPeps .Copy ( &(Model->CisPeps) ); } } void CModel::CopyHets ( PCModel Model ) { if (Model) HetCompounds.Copy ( &(Model->HetCompounds) ); } void CModel::CopySecStructure ( PCModel Model ) { if (Model) { Helices.Copy ( &(Model->Helices) ); Sheets .Copy ( &(Model->Sheets) ); Turns .Copy ( &(Model->Turns) ); } } void CModel::CopyLinks ( PCModel Model ) { if (Model) Links.Copy ( &(Model->Links) ); } void CModel::CopyLinkRs ( PCModel Model ) { if (Model) LinkRs.Copy ( &(Model->LinkRs) ); } void CModel::CopyCisPeps ( PCModel Model ) { if (Model) CisPeps.Copy ( &(Model->CisPeps) ); } void CModel::_copy ( PCModel Model ) { // modify both CModel::_copy and CModel::Copy methods simultaneously! int i; FreeMemory(); if (Model) { serNum = Model->serNum; nChains = Model->nChains; nChainsAlloc = nChains; if (nChains>0) { Chain = new PCChain[nChainsAlloc]; for (i=0;iChain[i]) { Chain[i] = newCChain(); Chain[i]->SetModel ( this ); Chain[i]->_copy ( Model->Chain[i] ); } else Chain[i] = NULL; } } HetCompounds.Copy ( &(Model->HetCompounds) ); Helices .Copy ( &(Model->Helices) ); Sheets .Copy ( &(Model->Sheets) ); Turns .Copy ( &(Model->Turns) ); Links .Copy ( &(Model->Links) ); LinkRs .Copy ( &(Model->LinkRs) ); CisPeps .Copy ( &(Model->CisPeps) ); } } void CModel::_copy ( PCModel Model, PPCAtom atom, int & atom_index ) { // modify both CModel::_copy and CModel::Copy methods simultaneously! // // _copy(PCModel,PPCAtom,int&) does copy atoms into array 'atom' // starting from position atom_index. 'atom' should be able to // accept all new atoms - no checks on the length of 'atom' // is being made. This function should not be used in applications. int i; FreeMemory(); if (Model) { serNum = Model->serNum; nChains = Model->nChains; nChainsAlloc = nChains; if (nChains>0) { Chain = new PCChain[nChainsAlloc]; for (i=0;iChain[i]) { Chain[i] = newCChain(); Chain[i]->SetModel ( this ); Chain[i]->_copy ( Model->Chain[i],atom,atom_index ); } else Chain[i] = NULL; } } HetCompounds.Copy ( &(Model->HetCompounds) ); Helices .Copy ( &(Model->Helices) ); Sheets .Copy ( &(Model->Sheets) ); Turns .Copy ( &(Model->Turns) ); Links .Copy ( &(Model->Links) ); LinkRs .Copy ( &(Model->LinkRs) ); } } int CModel::AddChain ( PCChain chain ) { // modify both CModel::Copy methods simultaneously! // // Copy(PCModel,PPCAtom,int&) copies atoms into array 'atom' // starting from position atom_index. 'atom' should be able to // accept all new atoms - no checks on the length of 'atom' // is being made. This function should not be used in applications. PCModel model1; int i; for (i=0;iGetCoordHierarchy()) { // The chain is associated with a coordinate hierarchy. It should // remain there, therefore we physically copy all its residues // and atoms. Chain[nChains] = newCChain(); Chain[nChains]->SetModel ( this ); if (manager) { // get space for new atoms manager->AddAtomArray ( chain->GetNumberOfAtoms(True) ); Chain[nChains]->_copy ( chain,manager->Atom,manager->nAtoms ); } else { for (i=0;inResidues;i++) Chain[nChains]->AddResidue ( chain->Residue[i] ); } } else { // The chain is not associated with a coordinate hierarchy. Such // unregistered objects are simply taken over, i.e. moved into // the new destination (model). Chain[nChains] = chain; // remove chain from its model: model1 = chain->GetModel(); if (model1) for (i=0;inChains;i++) if (model1->Chain[i]==chain) { model1->Chain[i] = NULL; break; } Chain[nChains]->SetModel ( this ); if (manager) Chain[nChains]->CheckInAtoms(); } nChains++; } return nChains; } void CModel::MoveChain ( PCChain & m_chain, PPCAtom m_atom, PPCAtom atom, int & atom_index, int chain_ext ) { // MoveChain(..) adds chain m_chain on the top Chain array. // The pointer on chain is then set to NULL (m_chain=NULL). // If chain_ext is greater than 0, the moved chain will be // forcefully renamed; the new name is composed as the previous // one + underscore + chain_ext (e.g. A_1). If thus generated // name duplicates any of existing chain IDs, or if chain_ext // was set to 0 and there is a duplication of chain IDs, the // name is again modified as above, with the extension number // generated automatically (this may result in IDs like // A_1_10). // m_atom must give pointer to the Atom array, from which // the atoms belonging to m_chain, are moved to Atom array // given by 'atom', starting from poisition 'atom_index'. // 'atom_index' is then automatically updated to the next // free position in 'atom'. // Note1: the moved atoms will occupy a continuous range // in 'atom' array; no checks on whether the corresponding // cells are occupied or not, are performed. // Note2: the 'atom_index' is numbered from 0 on, i.e. // it is equal to atom[atom_index]->index-1; atom[]->index // is assigned automatically. ChainID chainID; int i,j,k,Ok; PPCChain Chain1; PCResidue crRes; if (!m_chain) return; // modify chain ID with the extension given if (chain_ext>0) sprintf ( chainID,"%s_%i",m_chain->chainID,chain_ext ); else strcpy ( chainID,m_chain->chainID ); // Choose the chain ID. If a chain with such ID is // already present in the model, it will be assigned // a new ID 'ID_n', where 'ID' stands for the original // chain ID and 'n' is the minimum (integer) number // chosen such that 'name_n' represents a new chain ID // (in the model). k = 0; do { Ok = True; for (i=0;(ichainID)) Ok = False; if (!Ok) { k++; if (chain_ext>0) sprintf ( chainID,"%s_%i_%i",m_chain->chainID, chain_ext,k ); else sprintf ( chainID,"%s_%i",m_chain->chainID,k ); } } while (!Ok); // add chain on the top of Chain array. strcpy ( m_chain->chainID,chainID ); if (nChains>=nChainsAlloc) { nChainsAlloc = nChains+10; Chain1 = new PCChain[nChainsAlloc]; k = 0; for (i=0;iSetModel ( this ); nChains++; // Move all atoms of the chain. While residues belong // atoms belong to the chain's manager class. Therefore // they should be moved from one manager to another. for (i=0;inResidues;i++) { crRes = m_chain->Residue[i]; if (crRes) for (j=0;jnAtoms;j++) if (crRes->atom[j]) { k = crRes->atom[j]->index-1; atom[atom_index] = m_atom[k]; atom[atom_index]->index = atom_index+1; atom_index++; m_atom[k] = NULL; // moved! } } m_chain = NULL; // moved! } void CModel::GetAIndexRange ( int & i1, int & i2 ) { PCChain chain; PCResidue res; int ic,ir,ia; i1 = MaxInt4; i2 = MinInt4; for (ic=0;icnResidues;ir++) { res = chain->Residue[ir]; if (res) { for (ia=0;ianAtoms;ia++) if (res->atom[ia]) { if (res->atom[ia]->indexatom[ia]->index; if (res->atom[ia]->index>i2) i2 = res->atom[ia]->index; } } } } } } void CModel::MaskAtoms ( PCMask Mask ) { int i; for (i=0;iMaskAtoms ( Mask ); } void CModel::MaskResidues ( PCMask Mask ) { int i; for (i=0;iMaskResidues ( Mask ); } void CModel::MaskChains ( PCMask Mask ) { int i; for (i=0;iSetMask ( Mask ); } void CModel::UnmaskAtoms ( PCMask Mask ) { int i; for (i=0;iUnmaskAtoms ( Mask ); } void CModel::UnmaskResidues ( PCMask Mask ) { int i; for (i=0;iUnmaskResidues ( Mask ); } void CModel::UnmaskChains ( PCMask Mask ) { int i; for (i=0;iRemoveMask ( Mask ); } // ------ Getting Secondary Structure Elements int CModel::GetNumberOfHelices() { return Helices.Length(); } int CModel::GetNumberOfSheets() { return Sheets.nSheets; } PCHelix CModel::GetHelix ( int serialNum ) { return (PCHelix)Helices.GetContainerClass ( serialNum-1 ); } void CModel::GetSheetID ( int serialNum, SheetID sheetID ) { if ((1<=serialNum) && (serialNum<=Sheets.nSheets)) { if (Sheets.Sheet[serialNum-1]) { strcpy ( sheetID,Sheets.Sheet[serialNum-1]->sheetID ); return; } } sheetID[0] = char(0); } PCSheet CModel::GetSheet ( int serialNum ) { if ((1<=serialNum) && (serialNum<=Sheets.nSheets)) return Sheets.Sheet[serialNum-1]; else return NULL; } PCSheet CModel::GetSheet ( const SheetID sheetID ) { int i; for (i=0;isheetID,sheetID)) return Sheets.Sheet[i]; } return NULL; } int CModel::GetNumberOfStrands ( int sheetSerNum ) { if ((1<=sheetSerNum) && (sheetSerNum<=Sheets.nSheets)) { if (Sheets.Sheet[sheetSerNum-1]) return Sheets.Sheet[sheetSerNum-1]->nStrands; } return 0; } int CModel::GetNumberOfStrands ( const SheetID sheetID ) { int i; for (i=0;isheetID,sheetID)) return Sheets.Sheet[i]->nStrands; } return 0; } PCStrand CModel::GetStrand ( int sheetSerNum, int strandSerNum ) { PCSheet Sheet; if ((1<=sheetSerNum) && (sheetSerNum<=Sheets.nSheets)) { Sheet = Sheets.Sheet[sheetSerNum-1]; if (Sheet) { if ((1<=strandSerNum) && (strandSerNum<=Sheet->nStrands)) return Sheet->Strand[strandSerNum-1]; } } return NULL; } PCStrand CModel::GetStrand ( const SheetID sheetID, int strandSerNum ) { int i; PCSheet Sheet; for (i=0;isheetID,sheetID)) { Sheet = Sheets.Sheet[i]; if (Sheet) { if ((1<=strandSerNum) && (strandSerNum<=Sheet->nStrands)) return Sheet->Strand[strandSerNum-1]; } } } return NULL; } void CModel::RemoveSecStructure() { Helices.FreeContainer(); Sheets .FreeMemory (); Turns .FreeContainer(); } void CModel::RemoveHetInfo() { HetCompounds.FreeMemory(); } int CModel::GetNumberOfLinks() { return Links.Length(); } PCLink CModel::GetLink ( int serialNum ) { return (PCLink)Links.GetContainerClass ( serialNum-1 ); } void CModel::RemoveLinks() { Links.FreeContainer(); } void CModel::AddLink ( PCLink Link ) { Links.AddData ( Link ); } int CModel::GetNumberOfLinkRs() { return LinkRs.Length(); } PCLinkR CModel::GetLinkR ( int serialNum ) { return (PCLinkR)LinkRs.GetContainerClass ( serialNum-1 ); } void CModel::RemoveLinkRs() { LinkRs.FreeContainer(); } void CModel::AddLinkR ( PCLinkR LinkR ) { LinkRs.AddData ( LinkR ); } int CModel::GetNumberOfCisPeps() { return CisPeps.Length(); } PCCisPep CModel::GetCisPep ( int CisPepNum ) { return (PCCisPep)CisPeps.GetContainerClass ( CisPepNum-1 ); } void CModel::RemoveCisPeps() { CisPeps.FreeContainer(); } void CModel::AddCisPep ( PCCisPep CisPep ) { CisPeps.AddData ( CisPep ); } void CModel::ApplyTransform ( mat44 & TMatrix ) { // transforms all coordinates by multiplying with matrix TMatrix int i; for (i=0;iApplyTransform ( TMatrix ); } Boolean CModel::isInSelection ( int selHnd ) { PCMask Mask; if (manager) { Mask = PCMMDBFile(manager)->GetSelMask ( selHnd ); if (Mask) return CheckMask ( Mask ); } return False; } // ------- user-defined data handlers int CModel::PutUDData ( int UDDhandle, int iudd ) { if (UDDhandle & UDRF_MODEL) return CUDData::putUDData ( UDDhandle,iudd ); else return UDDATA_WrongUDRType; } int CModel::PutUDData ( int UDDhandle, realtype rudd ) { if (UDDhandle & UDRF_MODEL) return CUDData::putUDData ( UDDhandle,rudd ); else return UDDATA_WrongUDRType; } int CModel::PutUDData ( int UDDhandle, cpstr sudd ) { if (UDDhandle & UDRF_MODEL) return CUDData::putUDData ( UDDhandle,sudd ); else return UDDATA_WrongUDRType; } int CModel::GetUDData ( int UDDhandle, int & iudd ) { if (UDDhandle & UDRF_MODEL) return CUDData::getUDData ( UDDhandle,iudd ); else return UDDATA_WrongUDRType; } int CModel::GetUDData ( int UDDhandle, realtype & rudd ) { if (UDDhandle & UDRF_MODEL) return CUDData::getUDData ( UDDhandle,rudd ); else return UDDATA_WrongUDRType; } int CModel::GetUDData ( int UDDhandle, pstr sudd, int maxLen ) { if (UDDhandle & UDRF_MODEL) return CUDData::getUDData ( UDDhandle,sudd,maxLen ); else return UDDATA_WrongUDRType; } int CModel::GetUDData ( int UDDhandle, pstr & sudd ) { if (UDDhandle & UDRF_MODEL) return CUDData::getUDData ( UDDhandle,sudd ); else return UDDATA_WrongUDRType; } // ------- calculation of Secondary Structure int CModel::CalcSecStructure ( Boolean flagBulge, int aminoSelHnd ) { // This function is contributed by Liz Potterton, University of York //------------------------------------------------------------------ // Define a secondary structure type of each amino acid residue in the // structure. // Procedure: // Find all amino acids // Find all pairs of amino acids which have inter-Ca distance < 10.0A // Test for hydrogen bonds between the main chain N and O of the close // residues and store the information in the hbonds matrix // Analyse the info in hbonds matrix to assign secondary structure to // secstr vector PPCResidue Res; PPCAtom Ca; PCChain chain; PSContact contact; imatrix hbonds; PPCAtom * hbond_atoms; int nres, ncontacts; int ir1,ir2, irdif; int i,j,k,l; // 1a. Get protein residues from selection handle if (aminoSelHnd>=0) { manager->GetSelIndex(aminoSelHnd,Res,nres); // printf ( " nres %3i " ,nres ); if (nres<=0) return SSERC_noResidues; } else { // 1b. Get all protein residues nres = 0; for (i=0;inResidues; if (nres<=0) return SSERC_noResidues; Res = new PCResidue[nres]; nres = 0; for (i=0;inResidues; for (j=0;jResidue[j]; } } if (nres<=0) { delete[] Res; return SSERC_noResidues; } } // 2. Get C-alphas of all aminoacids Ca = new PCAtom[nres]; k = 0; for (i=0;i=0 || Res[i]->isAminoacid()) { Ca[i] = Res[i]->GetAtom("CA", " C", "*"); k++; } else Ca[i] = NULL; Res[i]->SSE = SSE_None; } else Ca[i] = NULL; if (k<=0) { delete[] Res; delete[] Ca; return SSERC_noAminoacids; } // 3. Find all close Calphas - i.e. find the contacts between // the two equivalent sets of Ca atoms contact = NULL; ncontacts = 0; manager->SeekContacts ( Ca,nres, Ca,nres, 2.0,10.0, 2, contact,ncontacts,0 ); if (ncontacts<=0) { delete[] Res; delete[] Ca; if (contact) delete[] contact; return SSERC_noSSE; } // 4. Get and initialize memory for analysing the SSE GetMatrixMemory ( hbonds,nres,3,0,0 ); hbond_atoms = new PPCAtom[nres]; for (i=0;i2) { // test if there is donor Hbond from residue ir1 if (Res[ir1]->isMainchainHBond(Res[ir2])) { k = 0; while ((hbonds[ir1][k]!=0) && (k<2)) k++; hbonds [ir1][k] = -irdif; hbond_atoms[ir1][k] = Res[ir1]->GetAtom ( "N" ); hbond_atoms[ir1][k+3] = Res[ir2]->GetAtom ( "O" ); } // test if there is donor Hbond from residue ir2 if (Res[ir2]->isMainchainHBond(Res[ir1])) { k = 0; while ((hbonds[ir2][k]!=0) && (k<2)) k++; hbonds [ir2][k] = irdif; hbond_atoms[ir2][k] = Res[ir2]->GetAtom ( "N" ); hbond_atoms[ir2][k+3] = Res[ir1]->GetAtom ( "O" ); } } } // 6. Assign the turns - if there is bifurcated bond then the 4-turn // takes precedence - read the paper to make sense of this for (i=0;iSSE = SSE_5Turn; Res[i-2]->SSE = SSE_5Turn; Res[i-3]->SSE = SSE_5Turn; Res[i-4]->SSE = SSE_5Turn; } if (hbonds[i][k]==-3) { Res[i-1]->SSE = SSE_3Turn; Res[i-2]->SSE = SSE_3Turn; } k++; } } for (i=0;iSSE = SSE_4Turn; Res[i-2]->SSE = SSE_4Turn; Res[i-3]->SSE = SSE_4Turn; } k++; } } // 7. Look for consecutive 4-turns which make alpha helix for (i=1;iSSE==SSE_Helix) || (Res[i ]->SSE==SSE_4Turn)) && ((Res[i+1]->SSE==SSE_Helix) || (Res[i+1]->SSE==SSE_4Turn)) && ((Res[i+2]->SSE==SSE_Helix) || (Res[i+2]->SSE==SSE_4Turn)) && ((Res[i+3]->SSE==SSE_Helix) || (Res[i+3]->SSE==SSE_4Turn))) for (j=i;j<=i+3;j++) Res[j]->SSE = SSE_Helix; } for (i=0;iSSE = SSE_Strand; Res[j]->SSE = SSE_Strand; } // Parallel strand if (hbonds[j][l]==-irdif-2) { Res[i-1]->SSE = SSE_Strand; Res[j ]->SSE = SSE_Strand; } // Parallel beta bulge if (hbonds[j][l]==-irdif-3) { if (flagBulge) { if (Res[i-1]->SSE==SSE_None) Res[i-1]->SSE = SSE_Bulge; if (Res[i-2]->SSE==SSE_None) Res[i-2]->SSE = SSE_Bulge; if (Res[j ]->SSE==SSE_None) Res[j ]->SSE = SSE_Bulge; } else { if (Res[i-1]->SSE==SSE_None) Res[i-1]->SSE = SSE_Strand; if (Res[i-2]->SSE==SSE_None) Res[i-2]->SSE = SSE_Strand; if (Res[j ]->SSE==SSE_None) Res[j ]->SSE = SSE_Strand; } } l++; } // Test for 'wide' hbond j = i + hbonds[i][k] + 2; if (jSSE = SSE_Strand; Res[j-1]->SSE = SSE_Strand; } // Parallel strands if (hbonds[j][l]==-irdif-2) { Res[i ]->SSE = SSE_Strand; Res[j-1]->SSE = SSE_Strand; } l++; } } // test for anti-parallel B-bulge between 'close' hbonds j = i + hbonds[i][k] - 1; if (j>=0) { l = 0; while ((l<=2) && (hbonds[j][l]!=0)) { if (hbonds[j][l]==-irdif+1) { if (flagBulge) { if (Res[i ]->SSE==SSE_None) Res[i ]->SSE = SSE_Bulge; if (Res[j+1]->SSE==SSE_None) Res[j+1]->SSE = SSE_Bulge; if (Res[j ]->SSE==SSE_None) Res[j ]->SSE = SSE_Bulge; } else { if (Res[i ]->SSE==SSE_None) Res[i ]->SSE = SSE_Strand; if (Res[j+1]->SSE==SSE_None) Res[j+1]->SSE = SSE_Strand; if (Res[j ]->SSE==SSE_None) Res[j ]->SSE = SSE_Strand; } } l++; } } // test for anti-parallel B-bulge between 'wide' hbonds j = i + hbonds[i][k] + 3; if (j0)) { if (flagBulge) { if (Res[i-1]->SSE==SSE_None) Res[i-1]->SSE = SSE_Bulge; if (Res[j-1]->SSE==SSE_None) Res[j-1]->SSE = SSE_Bulge; if (Res[j-2]->SSE==SSE_None) Res[j-2]->SSE = SSE_Bulge; } else { if (Res[i-1]->SSE==SSE_None) Res[i-1]->SSE = SSE_Strand; if (Res[j-1]->SSE==SSE_None) Res[j-1]->SSE = SSE_Strand; if (Res[j-2]->SSE==SSE_None) Res[j-2]->SSE = SSE_Strand; } } else if (hbonds[j][l]==-irdif-3) { // and bulge in parallel strand if (flagBulge) { if (Res[i ]->SSE==SSE_None) Res[i ]->SSE = SSE_Bulge; if (Res[j-1]->SSE==SSE_None) Res[j-1]->SSE = SSE_Bulge; if (Res[j-2]->SSE==SSE_None) Res[j-2]->SSE = SSE_Bulge; } else { if (Res[i ]->SSE==SSE_None) Res[i ]->SSE = SSE_Strand; if (Res[j-1]->SSE==SSE_None) Res[j-1]->SSE = SSE_Strand; if (Res[j-2]->SSE==SSE_None) Res[j-2]->SSE = SSE_Strand; } } l++; } } k++; } // Finish looping over Hbonds for residue (k loop) } // Finish looping over residues ( i loop) // 8. Free memory if (hbond_atoms) { for (i=0;iwrite ( f ); } HetCompounds.write ( f ); Helices .write ( f ); Sheets .write ( f ); Turns .write ( f ); Links .write ( f ); LinkRs .write ( f ); } void CModel::read ( RCFile f ) { int i,k; byte Version; FreeMemory(); f.ReadByte ( &Version ); CProModel::read ( f ); f.ReadInt ( &serNum ); f.ReadInt ( &nChains ); nChainsAlloc = nChains; if (nChains>0) { Chain = new PCChain[nChainsAlloc]; for (i=0;iSetModel ( this ); Chain[i]->read ( f ); } } } HetCompounds.read ( f ); Helices .read ( f ); Sheets .read ( f ); Turns .read ( f ); if (Version>1) Links .read ( f ); if (Version>2) LinkRs.read ( f ); } MakeFactoryFunctions(CModel) mmdb-1.25.5/mmdb/mmdb_coormngr.cpp0000775000175000017500000035054212133550634013734 00000000000000// $Id: mmdb_coormngr.cpp,v 1.28 2012/01/26 17:52:20 ekr Exp $ // ================================================================= // // CCP4 Coordinate Library: support of coordinate-related // functionality in protein crystallography applications. // // Copyright (C) Eugene Krissinel 2000-2008. // // This library is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // // ================================================================= // // 26.01.09 <-- Date of Last Modification. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ----------------------------------------------------------------- // // **** Module : mmdb_coormngr // ~~~~~~~~~ // **** Project : MacroMolecular Data Base (MMDB) // ~~~~~~~~~ // **** Classes : CBrick ( space brick ) // ~~~~~~~~~ CMBrick ( "multiple" space brick ) // CMMDBCoorManager ( MMDB atom coordinate manager ) // // Copyright (C) E. Krissinel 2000-2009 // // ================================================================= // #ifndef __MATH_H #include #endif #ifndef __STRING_H #include #endif #ifndef __LinAlg__ #include "linalg_.h" #endif #ifndef __MMDB_CoorMngr__ #include "mmdb_coormngr.h" #endif #ifndef __MMDB_Tables__ #include "mmdb_tables.h" #endif // =========================== CBrick ============================== CBrick::CBrick() { InitBrick(); } CBrick::~CBrick() { Clear(); } void CBrick::InitBrick() { Atom = NULL; id = NULL; nAtoms = 0; nAllocAtoms = 0; } void CBrick::Clear() { if (Atom) delete[] Atom; FreeVectorMemory ( id,0 ); Atom = NULL; nAtoms = 0; nAllocAtoms = 0; } void CBrick::AddAtom ( PCAtom A, int atomid ) { int i; PPCAtom Atom1; ivector id1; if (nAtoms>=nAllocAtoms) { nAllocAtoms = nAtoms+10; Atom1 = new PCAtom[nAllocAtoms]; GetVectorMemory ( id1,nAllocAtoms,0 ); for (i=0;i=nalloc) { nalloc = natoms+10; Atom1 = new PCAtom[nalloc]; GetVectorMemory ( id1,nalloc,0 ); for (i=0;inOpAlloc) { ch1ID = new PChainID[Nops]; ch2ID = new PChainID[Nops]; GetVectorMemory ( nChains1,Nops,0 ); for (i=0;i0) { nOpAlloc = Nops; chID1 = new PChainID[Nops]; chID2 = new PChainID[Nops]; GetVectorMemory ( nChains,Nops,0 ); for (i=0;inChains[i]; if (nChains[i]<=0) { chID1[i] = NULL; chID2[i] = NULL; } else { chID1[i] = new ChainID[nChains[i]]; chID2[i] = new ChainID[nChains[i]]; for (j=0;jchID1[i][j] ); strcpy ( chID2[i][j],PCGenSym(GenSym)->chID2[i][j] ); } } } } } void CGenSym::write ( RCFile f ) { int i,j; byte Version=1; f.WriteByte ( &Version ); CSymOps::write ( f ); f.WriteInt ( &nOpAlloc ); for (i=0;i0) { chID1 = new PChainID[nOpAlloc]; chID2 = new PChainID[nOpAlloc]; GetVectorMemory ( nChains,nOpAlloc,0 ); for (i=0;i0) { chID1[i] = new ChainID[nChains[i]]; chID2[i] = new ChainID[nChains[i]]; for (j=0;j0) { if (n_contacts=alloc_index) { alloc_index = n_contacts+IMax(alloc_index/4+10,10); if ((alloc_max>0) && (alloc_index>alloc_max)) alloc_index = alloc_max; cont1 = new SContact[alloc_index]; for (i=0;i0) { Atom = new PPCAtom[nStruct]; id = new ivector[nStruct]; GetVectorMemory ( nAtoms,nStruct,0 ); GetVectorMemory ( nAlloc,nStruct,0 ); for (i=0;i=nal) { nal = nat+10; A2 = new PCAtom[nal]; GetVectorMemory ( id2,nal,0 ); for (i=0;iGetSerNum(); return 1; } PCModel CMMDBCoorManager::GetModel ( int modelNo ) { if ((modelNo>=1) && (modelNo<=nModels)) return Model[modelNo-1]; else return NULL; } PCModel CMMDBCoorManager::GetModel ( cpstr CID ) { int modno,sn,rc; ChainID chname; InsCode ic; ResName resname; AtomName aname; Element elname; AltLoc aloc; CoorIDCode = CID_Ok; rc = ParseAtomPath ( CID,modno,chname,sn,ic,resname, aname,elname,aloc,&DefPath ); if ((rc<0) || (rc & APATH_WC_ModelNo)) { CoorIDCode = CID_WrongPath; return NULL; } if ((modno>=1) && (modno<=nModels)) return Model[modno-1]; else return NULL; } void CMMDBCoorManager::GetModelTable ( PPCModel & modelTable, int & NumberOfModels ) { NumberOfModels = nModels; modelTable = Model; } int CMMDBCoorManager::DeleteModel ( int modelNo ) { if ((modelNo>=1) && (modelNo<=nModels)) { if (Model[modelNo-1]) { Exclude = False; delete Model[modelNo-1]; Model[modelNo-1] = NULL; Exclude = True; return 1; } } return 0; } int CMMDBCoorManager::DeleteModel ( cpstr CID ) { int modno,sn,rc; ChainID chname; InsCode ic; ResName resname; AtomName aname; Element elname; AltLoc aloc; CoorIDCode = CID_Ok; rc = ParseAtomPath ( CID,modno,chname,sn,ic,resname, aname,elname,aloc,&DefPath ); if ((rc<0) || (rc & APATH_WC_ModelNo)) { CoorIDCode = CID_WrongPath; return 0; } if ((modno>=1) && (modno<=nModels)) { if (Model[modno-1]) { Exclude = False; delete Model[modno-1]; Model[modno-1] = NULL; Exclude = True; return 1; } } return 0; } int CMMDBCoorManager::DeleteSolvent() { int i,k; Exclude = False; k = 0; for (i=0;iDeleteSolvent(); Model[i]->TrimChainTable(); if (Model[i]->nChains<=0) { delete Model[i]; Model[i] = NULL; } } Exclude = True; return k; } // ---------------- Adding/Inserting models --------------- int CMMDBCoorManager::AddModel ( PCModel model ) { PPCModel model1; int i,nnat,nat1; for (i=0;iGetNumberOfAtoms ( True ); AddAtomArray ( nnat ); // get space for new atoms if (model->GetCoordHierarchy()) { SwitchModel ( nModels+1 ); // get one more model at the end nat1 = nAtoms; Model[nModels-1]->_copy ( model,Atom,nat1 ); Model[nModels-1]->serNum = nModels; nAtoms = nat1; } else { model1 = new PCModel[nModels+1]; for (i=0;iSetMMDBManager ( PCMMDBManager(this),nModels+1 ); Model[nModels]->CheckInAtoms(); nModels++; } return nModels; } int CMMDBCoorManager::InsModel ( PCModel model, int modelNo ) { AddModel ( model ); RotateModels ( modelNo,nModels,1 ); return nModels; } void CMMDBCoorManager::RotateModels ( int modelNo1, int modelNo2, int rotdir ) { PCModel model; PPCAtom A; int m1,m2,i11,i12,i21,i22,nat,i,k; m1 = IMax ( 0,modelNo1-1 ); m2 = IMin ( nModels,modelNo2) - 1; if (m1>m2) ISwap ( m1,m2 ); if (m1!=m2) { if (Model[m1] && Model[m2]) { Model[m1]->GetAIndexRange ( i11,i12 ); Model[m2]->GetAIndexRange ( i21,i22 ); if ((i11index = k+1; k++; } for (i=0;iindex = k+1; k++; } } else { // rotate anticlockwise nat = i22-i21+1; A = new PCAtom[nat]; k = 0; for (i=i21;i<=i22;i++) A[k++] = Atom[i]; k = i22; for (i=i21-1;i>=i11;i--) { Atom[k] = Atom[i]; if (Atom[k]) Atom[k]->index = k+1; k--; } for (i=nat-1;i>=0;i--) { Atom[k] = A[i]; if (Atom[k]) Atom[k]->index = k+1; k--; } } delete[] A; } } if (rotdir<0) { // rotate anticlockwise model = Model[m1]; for (i=m1;iserNum = i+1; } Model[m2] = model; Model[m2]->serNum = m2+1; } else { // rotate clockwise model = Model[m2]; for (i=m2;i>m1;i--) { Model[i] = Model[i-1]; Model[i]->serNum = i+1; } Model[m1] = model; Model[m1]->serNum = m1+1; } } } void CMMDBCoorManager::SwapModels ( int modelNo1, int modelNo2 ) { PCModel model; PPCAtom A; int m1,m2,i11,i12,i21,i22,i,k,n; n = 0; // tp depress "uninitialized" warning m1 = IMax ( 0,modelNo1-1 ); m2 = IMin ( nModels,modelNo2) - 1; if (m1>m2) ISwap ( m1,m2 ); if (m1!=m2) { if (Model[m1]) Model[m1]->GetAIndexRange ( i11,i12 ); else { n = m1; while ((!Model[n]) && (nGetAIndexRange ( i11,i12 ); i12 = i11-1; } else n = -1; } if (n>=0) { if (Model[m2]) Model[m2]->GetAIndexRange ( i21,i22 ); else { n = m2; while ((!Model[n]) && (m1GetAIndexRange ( i21,i22 ); i22 = i21-1; } else n = -1; } } if (n>=0) { i11--; i12--; i21--; i22--; A = new PCAtom[AtmLen]; k = 0; for (i=0 ;iindex = i+1; for (i=nAtoms;iserNum = m1+1; Model[m2]->serNum = m2+1; } } PCChain CMMDBCoorManager::GetChain ( int modelNo, const ChainID chainID ) { if ((0GetChain ( chainID ); } return NULL; } PCChain CMMDBCoorManager::GetChain ( int modelNo, int chainNo ) { if ((0GetChain ( chainNo ); } return NULL; } PCChain CMMDBCoorManager::GetChain ( cpstr CID ) { int modno,sn,rc; ChainID chname; InsCode ic; ResName resname; AtomName aname; Element elname; AltLoc aloc; CoorIDCode = CID_Ok; rc = ParseAtomPath ( CID,modno,chname,sn,ic,resname, aname,elname,aloc,&DefPath ); if ((rc<0) || (rc & (APATH_WC_ModelNo | APATH_WC_ChainID))) { CoorIDCode = CID_WrongPath; return NULL; } return GetChain ( modno,chname ); } void CMMDBCoorManager::GetChainTable ( int modelNo, PPCChain & chainTable, int & NumberOfChains ) { chainTable = NULL; NumberOfChains = 0; if ((0Chain; NumberOfChains = Model[modelNo-1]->nChains; } } } void CMMDBCoorManager::GetChainTable ( cpstr CID, PPCChain & chainTable, int & NumberOfChains ) { int modno,sn,rc; ChainID chname; InsCode ic; ResName resname; AtomName aname; Element elname; AltLoc aloc; chainTable = NULL; NumberOfChains = 0; CoorIDCode = CID_Ok; rc = ParseAtomPath ( CID,modno,chname,sn,ic,resname, aname,elname,aloc,&DefPath ); if ((rc<0) || (rc & APATH_WC_ModelNo)) { CoorIDCode = CID_WrongPath; return; } if ((0Chain; NumberOfChains = Model[modno-1]->nChains; } } } int CMMDBCoorManager::DeleteChain ( int modelNo, const ChainID chID ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->DeleteChain ( chID ); } return 0; } int CMMDBCoorManager::DeleteChain ( int modelNo, int chainNo ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->DeleteChain ( chainNo ); } return 0; } int CMMDBCoorManager::DeleteAllChains ( int modelNo ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->DeleteAllChains(); } return 0; } int CMMDBCoorManager::DeleteAllChains() { int i,k; k = 0; for (i=0;iDeleteAllChains(); return k; } int CMMDBCoorManager::AddChain ( int modelNo, PCChain chain ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->AddChain ( chain ); } return 0; } PCResidue CMMDBCoorManager::GetResidue ( int modelNo, const ChainID chainID, int seqNo, const InsCode insCode ) { if ((0GetResidue ( chainID,seqNo,insCode ); } return NULL; } PCResidue CMMDBCoorManager::GetResidue ( int modelNo, int chainNo, int seqNo, const InsCode insCode ) { if ((0GetResidue ( chainNo,seqNo,insCode ); } return NULL; } PCResidue CMMDBCoorManager::GetResidue ( int modelNo, const ChainID chainID, int resNo ) { if ((0GetResidue ( chainID,resNo ); } return NULL; } PCResidue CMMDBCoorManager::GetResidue ( int modelNo, int chainNo, int resNo ) { if ((0GetResidue ( chainNo,resNo ); } return NULL; } PCResidue CMMDBCoorManager::GetResidue ( cpstr CID ) { int modno,sn,rc; ChainID chname; InsCode ic; ResName resname; AtomName aname; Element elname; AltLoc aloc; CoorIDCode = CID_Ok; rc = ParseAtomPath ( CID,modno,chname,sn,ic,resname, aname,elname,aloc,&DefPath ); if ((rc<0) || (rc & (APATH_WC_ModelNo | APATH_WC_ChainID | APATH_WC_SeqNum | APATH_WC_InsCode))) { CoorIDCode = CID_WrongPath; return NULL; } return GetResidue ( modno,chname,sn,ic ); } int CMMDBCoorManager::GetResidueNo ( int modelNo, const ChainID chainID, int seqNo, const InsCode insCode ) { if ((0GetResidueNo ( chainID,seqNo,insCode ); } return -3; } int CMMDBCoorManager::GetResidueNo ( int modelNo, int chainNo, int seqNo, const InsCode insCode ) { if ((0GetResidueNo ( chainNo,seqNo,insCode ); } return -3; } void CMMDBCoorManager::GetResidueTable ( PPCResidue & resTable, int & NumberOfResidues ) { // resTable has to be NULL or it will be reallocated. The // application is responsible for deallocating the resTable (but not // of its residues!). This does not apply to other GetResidueTable // functions. PPCChain chain; PPCResidue res; int i,j,k,n,nChains,nResidues; if (resTable) { delete[] resTable; resTable = NULL; } NumberOfResidues = 0; for (i=0;iGetChainTable ( chain,nChains ); for (j=0;jnChains;j++) if (chain[j]) { chain[j]->GetResidueTable ( res,nResidues ); NumberOfResidues += nResidues; } } if (NumberOfResidues>0) { resTable = new PCResidue[NumberOfResidues]; k = 0; for (i=0;iGetChainTable ( chain,nChains ); for (j=0;jnChains;j++) if (chain[j]) { chain[j]->GetResidueTable ( res,nResidues ); for (n=0;nGetChain ( chainID ); if (chain) { resTable = chain->Residue; NumberOfResidues = chain->nResidues; } } } } void CMMDBCoorManager::GetResidueTable ( int modelNo, int chainNo, PPCResidue & resTable, int & NumberOfResidues ) { PCChain chain; resTable = NULL; NumberOfResidues = 0; if ((0GetChain ( chainNo ); if (chain) { resTable = chain->Residue; NumberOfResidues = chain->nResidues; } } } } void CMMDBCoorManager::GetResidueTable ( cpstr CID, PPCResidue & resTable, int & NumberOfResidues ) { int modno,sn,rc; ChainID chname; InsCode ic; ResName resname; AtomName aname; Element elname; AltLoc aloc; PCChain chain; resTable = NULL; NumberOfResidues = 0; CoorIDCode = CID_Ok; rc = ParseAtomPath ( CID,modno,chname,sn,ic,resname, aname,elname,aloc,&DefPath ); if ((rc<0) || (rc & (APATH_WC_ModelNo | APATH_WC_ChainID))) { CoorIDCode = CID_WrongPath; return; } if ((0GetChain ( chname ); if (chain) { resTable = chain->Residue; NumberOfResidues = chain->nResidues; } } } } int CMMDBCoorManager::DeleteResidue ( int modelNo, const ChainID chainID, int seqNo, const InsCode insCode ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->DeleteResidue ( chainID,seqNo,insCode ); } return 0; } int CMMDBCoorManager::DeleteResidue ( int modelNo, const ChainID chainID, int resNo ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->DeleteResidue ( chainID,resNo ); } return 0; } int CMMDBCoorManager::DeleteResidue ( int modelNo, int chainNo, int seqNo, const InsCode insCode ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->DeleteResidue ( chainNo,seqNo,insCode ); } return 0; } int CMMDBCoorManager::DeleteResidue ( int modelNo, int chainNo, int resNo ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->DeleteResidue ( chainNo,resNo ); } return 0; } int CMMDBCoorManager::DeleteAllResidues ( int modelNo, const ChainID chainID ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->DeleteAllResidues ( chainID ); } return 0; } int CMMDBCoorManager::DeleteAllResidues ( int modelNo, int chainNo ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->DeleteAllResidues ( chainNo ); } return 0; } int CMMDBCoorManager::DeleteAllResidues ( int modelNo ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->DeleteAllResidues(); } return 0; } int CMMDBCoorManager::DeleteAllResidues() { int i,k; k = 0; for (i=0;iDeleteAllResidues(); return k; } int CMMDBCoorManager::AddResidue ( int modelNo, const ChainID chainID, PCResidue res ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->AddResidue ( chainID,res ); } return 0; } int CMMDBCoorManager::AddResidue ( int modelNo, int chainNo, PCResidue res ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->AddResidue ( chainNo,res ); } return 0; } int CMMDBCoorManager::GetNumberOfChains ( int modelNo ) { if ((0nChains; } return 0; } int CMMDBCoorManager::GetNumberOfChains ( cpstr CID ) { int modno,sn,rc; ChainID chname; InsCode ic; ResName resname; AtomName aname; Element elname; AltLoc aloc; CoorIDCode = CID_Ok; rc = ParseAtomPath ( CID,modno,chname,sn,ic,resname, aname,elname,aloc,&DefPath ); if ((rc<0) || (rc & APATH_WC_ModelNo)) { CoorIDCode = CID_WrongPath; return 0; } if ((0nChains; } return 0; } int CMMDBCoorManager::GetNumberOfResidues ( int modelNo, const ChainID chainID ) { PCChain chain; if ((0GetChain ( chainID ); if (chain) return chain->nResidues; } } return 0; } int CMMDBCoorManager::GetNumberOfResidues ( int modelNo, int chainNo ) { PCChain chain; if ((0nChains)) { chain = Model[modelNo-1]->Chain[chainNo]; if (chain) return chain->nResidues; } } } return 0; } int CMMDBCoorManager::GetNumberOfResidues ( cpstr CID ) { int modno,sn,rc; ChainID chname; InsCode ic; ResName resname; AtomName aname; Element elname; AltLoc aloc; PCChain chain; CoorIDCode = CID_Ok; rc = ParseAtomPath ( CID,modno,chname,sn,ic,resname, aname,elname,aloc,&DefPath ); if ((rc<0) || (rc & (APATH_WC_ModelNo | APATH_WC_ChainID))) { CoorIDCode = CID_WrongPath; return 0; } if ((0GetChain ( chname ); if (chain) return chain->nResidues; } } return 0; } int CMMDBCoorManager::GetNumberOfAtoms ( int modelNo, const ChainID chainID, int seqNo, const InsCode insCode ) { PCChain chain; PCResidue res; if ((0GetChain ( chainID ); if (chain) { res = chain->GetResidue ( seqNo,insCode ); if (res) return res->nAtoms; } } } return 0; } int CMMDBCoorManager::GetNumberOfAtoms ( int modelNo, int chainNo, int seqNo, const InsCode insCode ) { PCChain chain; PCResidue res; if ((0nChains)) { chain = Model[modelNo-1]->Chain[chainNo]; if (chain) { res = chain->GetResidue ( seqNo,insCode ); if (res) return res->nAtoms; } } } } return 0; } int CMMDBCoorManager::GetNumberOfAtoms ( int modelNo, const ChainID chainID, int resNo ) { PCChain chain; PCResidue res; if ((0GetChain ( chainID ); if (chain) { if ((0<=resNo) && (resNonResidues)) { res = chain->Residue[resNo]; if (res) return res->nAtoms; } } } } return 0; } int CMMDBCoorManager::GetNumberOfAtoms ( int modelNo, int chainNo, int resNo ) { PCChain chain; PCResidue res; if ((0nChains)) { chain = Model[modelNo-1]->Chain[chainNo]; if (chain) { if ((0<=resNo) && (resNonResidues)) { res = chain->Residue[resNo]; if (res) return res->nAtoms; } } } } } return 0; } int CMMDBCoorManager::GetNumberOfAtoms ( cpstr CID ) { // returns number of atoms in residues identified by CID int modno,sn,rc; ChainID chname; InsCode ic; ResName resname; AtomName aname; Element elname; AltLoc aloc; PCChain chain; PCResidue res; CoorIDCode = CID_Ok; rc = ParseAtomPath ( CID,modno,chname,sn,ic,resname, aname,elname,aloc,&DefPath ); if ((rc<0) || (rc & (APATH_WC_ModelNo | APATH_WC_ChainID | APATH_WC_SeqNum | APATH_WC_InsCode))) { CoorIDCode = CID_WrongPath; return 0; } if ((0GetChain ( chname ); if (chain) { res = chain->GetResidue ( sn,ic ); if (res) return res->nAtoms; } } } return 0; } // -------------------- Extracting atoms ----------------------- PCAtom CMMDBCoorManager::GetAtom ( int modelNo, // model serial number 1... const ChainID chID, // chain ID int seqNo, // residue sequence number const InsCode insCode, // residue insertion code const AtomName aname, // atom name const Element elmnt, // chemical element code or '*' const AltLoc aloc // alternate location indicator ) { PCModel mdl; PCChain chn; PCResidue res; PCAtom atm; if ((1<=modelNo) && (modelNo<=nModels)) mdl = Model[modelNo-1]; else mdl = NULL; if (!mdl) { CoorIDCode = CID_NoModel; return NULL; } chn = mdl->GetChain ( chID ); if (!chn) { CoorIDCode = CID_NoChain; return NULL; } res = chn->GetResidue ( seqNo,insCode ); if (!res) { CoorIDCode = CID_NoResidue; return NULL; } atm = res->GetAtom ( aname,elmnt,aloc ); if (!atm) CoorIDCode = CID_NoAtom; else CoorIDCode = CID_Ok; return atm; } PCAtom CMMDBCoorManager::GetAtom ( int modelNo, // model serial number 1... const ChainID chID, // chain ID int seqNo, // residue sequence number const InsCode insCode, // residue insertion code int atomNo // atom number 0.. ) { PCModel mdl; PCChain chn; PCResidue res; PCAtom atm; if ((1<=modelNo) && (modelNo<=nModels)) mdl = Model[modelNo-1]; else mdl = NULL; if (!mdl) { CoorIDCode = CID_NoModel; return NULL; } chn = mdl->GetChain ( chID ); if (!chn) { CoorIDCode = CID_NoChain; return NULL; } res = chn->GetResidue ( seqNo,insCode ); if (!res) { CoorIDCode = CID_NoResidue; return NULL; } if ((0<=atomNo) && (atomNonAtoms)) atm = res->atom[atomNo]; else atm = NULL; if (!atm) CoorIDCode = CID_NoAtom; else CoorIDCode = CID_Ok; return atm; } PCAtom CMMDBCoorManager::GetAtom ( int modelNo, // model serial number 1... const ChainID chID, // chain ID int resNo, // residue number 0.. const AtomName aname, // atom name const Element elmnt, // chemical element code or '*' const AltLoc aloc // alternate location indicator ) { PCModel mdl; PCChain chn; PCResidue res; PCAtom atm; if ((1<=modelNo) && (modelNo<=nModels)) mdl = Model[modelNo-1]; else mdl = NULL; if (!mdl) { CoorIDCode = CID_NoModel; return NULL; } chn = mdl->GetChain ( chID ); if (!chn) { CoorIDCode = CID_NoChain; return NULL; } if ((0<=resNo) && (resNonResidues)) res = chn->Residue[resNo]; else res = NULL; if (!res) { CoorIDCode = CID_NoResidue; return NULL; } atm = res->GetAtom ( aname,elmnt,aloc ); if (!atm) CoorIDCode = CID_NoAtom; else CoorIDCode = CID_Ok; return atm; } PCAtom CMMDBCoorManager::GetAtom ( int modelNo, // model serial number 1... const ChainID chID, // chain ID int resNo, // residue number 0.. int atomNo // atom number 0.. ) { PCModel mdl; PCChain chn; PCResidue res; PCAtom atm; if ((1<=modelNo) && (modelNo<=nModels)) mdl = Model[modelNo-1]; else mdl = NULL; if (!mdl) { CoorIDCode = CID_NoModel; return NULL; } chn = mdl->GetChain ( chID ); if (!chn) { CoorIDCode = CID_NoChain; return NULL; } if ((0<=resNo) && (resNonResidues)) res = chn->Residue[resNo]; else res = NULL; if (!res) { CoorIDCode = CID_NoResidue; return NULL; } if ((0<=atomNo) && (atomNonAtoms)) atm = res->atom[atomNo]; else atm = NULL; if (!atm) CoorIDCode = CID_NoAtom; else CoorIDCode = CID_Ok; return atm; } PCAtom CMMDBCoorManager::GetAtom ( int modelNo, // model serial number 1... int chNo, // chain number 0.. int seqNo, // residue sequence number const InsCode insCode, // residue insertion code const AtomName aname, // atom name const Element elmnt, // chemical element code or '*' const AltLoc aloc // alternate location indicator ) { PCModel mdl; PCChain chn; PCResidue res; PCAtom atm; if ((1<=modelNo) && (modelNo<=nModels)) mdl = Model[modelNo-1]; else mdl = NULL; if (!mdl) { CoorIDCode = CID_NoModel; return NULL; } if ((0<=chNo) && (chNonChains)) chn = mdl->Chain[chNo]; else chn = NULL; if (!chn) { CoorIDCode = CID_NoChain; return NULL; } res = chn->GetResidue ( seqNo,insCode ); if (!res) { CoorIDCode = CID_NoResidue; return NULL; } atm = res->GetAtom ( aname,elmnt,aloc ); if (!atm) CoorIDCode = CID_NoAtom; else CoorIDCode = CID_Ok; return atm; } PCAtom CMMDBCoorManager::GetAtom ( int modelNo, // model serial number 1... int chNo, // chain number 0... int seqNo, // residue sequence number const InsCode insCode, // residue insertion code int atomNo // atom number 0... ) { PCModel mdl; PCChain chn; PCResidue res; PCAtom atm; if ((1<=modelNo) && (modelNo<=nModels)) mdl = Model[modelNo-1]; else mdl = NULL; if (!mdl) { CoorIDCode = CID_NoModel; return NULL; } if ((0<=chNo) && (chNonChains)) chn = mdl->Chain[chNo]; else chn = NULL; if (!chn) { CoorIDCode = CID_NoChain; return NULL; } res = chn->GetResidue ( seqNo,insCode ); if (!res) { CoorIDCode = CID_NoResidue; return NULL; } if ((0<=atomNo) && (atomNonAtoms)) atm = res->atom[atomNo]; else atm = NULL; if (!atm) CoorIDCode = CID_NoAtom; else CoorIDCode = CID_Ok; return atm; } PCAtom CMMDBCoorManager::GetAtom ( int modelNo, // model serial number 1... int chNo, // chain number 0... int resNo, // residue number 0... const AtomName aname, // atom name const Element elmnt, // chemical element code or '*' const AltLoc aloc // alternate location indicator ) { PCModel mdl; PCChain chn; PCResidue res; PCAtom atm; if ((1<=modelNo) && (modelNo<=nModels)) mdl = Model[modelNo-1]; else mdl = NULL; if (!mdl) { CoorIDCode = CID_NoModel; return NULL; } if ((0<=chNo) && (chNonChains)) chn = mdl->Chain[chNo]; else chn = NULL; if (!chn) { CoorIDCode = CID_NoChain; return NULL; } if ((0<=resNo) && (resNonResidues)) res = chn->Residue[resNo]; else res = NULL; if (!res) { CoorIDCode = CID_NoResidue; return NULL; } atm = res->GetAtom ( aname,elmnt,aloc ); if (!atm) CoorIDCode = CID_NoAtom; else CoorIDCode = CID_Ok; return atm; } PCAtom CMMDBCoorManager::GetAtom ( int modelNo, // model serial number 1... int chNo, // chain number 0... int resNo, // residue number 0... int atomNo // atom number 0... ) { PCModel mdl; PCChain chn; PCResidue res; PCAtom atm; if ((1<=modelNo) && (modelNo<=nModels)) mdl = Model[modelNo-1]; else mdl = NULL; if (!mdl) { CoorIDCode = CID_NoModel; return NULL; } if ((0<=chNo) && (chNonChains)) chn = mdl->Chain[chNo]; else chn = NULL; if (!chn) { CoorIDCode = CID_NoChain; return NULL; } if ((0<=resNo) && (resNonResidues)) res = chn->Residue[resNo]; else res = NULL; if (!res) { CoorIDCode = CID_NoResidue; return NULL; } if ((0<=atomNo) && (atomNonAtoms)) atm = res->atom[atomNo]; else atm = NULL; if (!atm) CoorIDCode = CID_NoAtom; else CoorIDCode = CID_Ok; return atm; } PCAtom CMMDBCoorManager::GetAtom ( cpstr CID ) { int modno,sn,rc; ChainID chname; InsCode ic; ResName resname; AtomName aname; Element elname; AltLoc aloc; CoorIDCode = CID_Ok; rc = ParseAtomPath ( CID,modno,chname,sn,ic,resname, aname,elname,aloc,&DefPath ); if ((rc<0) || (rc & APATH_Incomplete)) { CoorIDCode = CID_WrongPath; return NULL; } return GetAtom ( modno,chname,sn,ic,aname,elname,aloc ); } void CMMDBCoorManager::GetAtomTable ( PPCAtom & atomTable, int & NumberOfAtoms ) { atomTable = Atom; NumberOfAtoms = nAtoms; } void CMMDBCoorManager::GetAtomTable ( int modelNo, const ChainID chainID, int seqNo, const InsCode insCode, PPCAtom & atomTable, int & NumberOfAtoms ) { PCResidue res; atomTable = NULL; NumberOfAtoms = 0; if ((0GetResidue ( chainID,seqNo,insCode ); if (res) { atomTable = res->atom; NumberOfAtoms = res->nAtoms; } } } } void CMMDBCoorManager::GetAtomTable ( int modelNo, int chainNo, int seqNo, const InsCode insCode, PPCAtom & atomTable, int & NumberOfAtoms ) { PCResidue res; atomTable = NULL; NumberOfAtoms = 0; if ((0GetResidue ( chainNo,seqNo,insCode ); if (res) { atomTable = res->atom; NumberOfAtoms = res->nAtoms; } } } } void CMMDBCoorManager::GetAtomTable ( int modelNo, const ChainID chainID, int resNo, PPCAtom & atomTable, int & NumberOfAtoms ) { PCResidue res; atomTable = NULL; NumberOfAtoms = 0; if ((0GetResidue ( chainID,resNo ); if (res) { atomTable = res->atom; NumberOfAtoms = res->nAtoms; } } } } void CMMDBCoorManager::GetAtomTable ( int modelNo, int chainNo, int resNo, PPCAtom & atomTable, int & NumberOfAtoms ) { PCResidue res; atomTable = NULL; NumberOfAtoms = 0; if ((0GetResidue ( chainNo,resNo ); if (res) { atomTable = res->atom; NumberOfAtoms = res->nAtoms; } } } } void CMMDBCoorManager::GetAtomTable ( cpstr CID, PPCAtom & atomTable, int & NumberOfAtoms ) { int modno,sn,rc; ChainID chname; InsCode ic; ResName resname; AtomName aname; Element elname; AltLoc aloc; PCResidue res; atomTable = NULL; NumberOfAtoms = 0; CoorIDCode = CID_Ok; rc = ParseAtomPath ( CID,modno,chname,sn,ic,resname, aname,elname,aloc,&DefPath ); if ((rc<0) || (rc & (APATH_WC_ModelNo | APATH_WC_ChainID | APATH_WC_SeqNum | APATH_WC_InsCode))) { CoorIDCode = CID_WrongPath; return; } res = GetResidue ( modno,chname,sn,ic ); if (res) { atomTable = res->atom; NumberOfAtoms = res->nAtoms; } } void CMMDBCoorManager::GetAtomTable1 ( PPCAtom & atomTable, int & NumberOfAtoms ) { int i,j; if (atomTable) delete[] atomTable; if (nAtoms>0) { atomTable = new PCAtom[nAtoms]; j = 0; for (i=0;iTer) atomTable[j++] = Atom[i]; } NumberOfAtoms = j; } else { atomTable = NULL; NumberOfAtoms = 0; } } void CMMDBCoorManager::GetAtomTable1 ( int modelNo, const ChainID chainID, int seqNo, const InsCode insCode, PPCAtom & atomTable, int & NumberOfAtoms ) { PCResidue res; res = NULL; if ((0GetResidue ( chainID,seqNo,insCode ); } if (res) res->GetAtomTable1 ( atomTable,NumberOfAtoms ); else { if (atomTable) delete[] atomTable; atomTable = NULL; NumberOfAtoms = 0; } } void CMMDBCoorManager::GetAtomTable1 ( int modelNo, int chainNo, int seqNo, const InsCode insCode, PPCAtom & atomTable, int & NumberOfAtoms ) { PCResidue res; res = NULL; if ((0GetResidue ( chainNo,seqNo,insCode ); } if (res) res->GetAtomTable1 ( atomTable,NumberOfAtoms ); else { if (atomTable) delete[] atomTable; atomTable = NULL; NumberOfAtoms = 0; } } void CMMDBCoorManager::GetAtomTable1 ( int modelNo, const ChainID chainID, int resNo, PPCAtom & atomTable, int & NumberOfAtoms ) { PCResidue res; res = NULL; if ((0GetResidue ( chainID,resNo ); } if (res) res->GetAtomTable1 ( atomTable,NumberOfAtoms ); else { if (atomTable) delete[] atomTable; atomTable = NULL; NumberOfAtoms = 0; } } void CMMDBCoorManager::GetAtomTable1 ( int modelNo, int chainNo, int resNo, PPCAtom & atomTable, int & NumberOfAtoms ) { PCResidue res; res = NULL; if ((0GetResidue ( chainNo,resNo ); } if (res) res->GetAtomTable1 ( atomTable,NumberOfAtoms ); else { if (atomTable) delete[] atomTable; atomTable = NULL; NumberOfAtoms = 0; } } void CMMDBCoorManager::GetAtomTable1 ( cpstr CID, PPCAtom & atomTable, int & NumberOfAtoms ) { int modno,sn,rc; ChainID chname; InsCode ic; ResName resname; AtomName aname; Element elname; AltLoc aloc; PCResidue res; atomTable = NULL; NumberOfAtoms = 0; CoorIDCode = CID_Ok; rc = ParseAtomPath ( CID,modno,chname,sn,ic,resname, aname,elname,aloc,&DefPath ); if ((rc<0) || (rc & (APATH_WC_ModelNo | APATH_WC_ChainID | APATH_WC_SeqNum | APATH_WC_InsCode))) { CoorIDCode = CID_WrongPath; return; } res = GetResidue ( modno,chname,sn,ic ); if (res) res->GetAtomTable1 ( atomTable,NumberOfAtoms ); else { if (atomTable) delete[] atomTable; atomTable = NULL; NumberOfAtoms = 0; } } int CMMDBCoorManager::DeleteAtom ( int modelNo, const ChainID chID, int seqNo, const InsCode insCode, const AtomName aname, const Element elmnt, const AltLoc aloc ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->DeleteAtom ( chID,seqNo,insCode, aname,elmnt,aloc ); } return 0; } int CMMDBCoorManager::DeleteAtom ( int modelNo, const ChainID chID, int seqNo, const InsCode insCode, int atomNo ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->DeleteAtom ( chID,seqNo,insCode,atomNo ); } return 0; } int CMMDBCoorManager::DeleteAtom ( int modelNo, const ChainID chID, int resNo, const AtomName aname, const Element elmnt, const AltLoc aloc ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->DeleteAtom ( chID,resNo, aname,elmnt,aloc ); } return 0; } int CMMDBCoorManager::DeleteAtom ( int modelNo, const ChainID chID, int resNo, int atomNo ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->DeleteAtom ( chID,resNo,atomNo ); } return 0; } int CMMDBCoorManager::DeleteAtom ( int modelNo, int chNo, int seqNo, const InsCode insCode, const AtomName aname, const Element elmnt, const AltLoc aloc ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->DeleteAtom ( chNo,seqNo,insCode, aname,elmnt,aloc ); } return 0; } int CMMDBCoorManager::DeleteAtom ( int modelNo, int chNo, int seqNo, const InsCode insCode, int atomNo ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->DeleteAtom ( chNo,seqNo,insCode,atomNo ); } return 0; } int CMMDBCoorManager::DeleteAtom ( int modelNo, int chNo, int resNo, const AtomName aname, const Element elmnt, const AltLoc aloc ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->DeleteAtom ( chNo,resNo, aname,elmnt,aloc ); } return 0; } int CMMDBCoorManager::DeleteAtom ( int modelNo, int chNo, int resNo, int atomNo ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->DeleteAtom ( chNo,resNo,atomNo ); } return 0; } int CMMDBCoorManager::DeleteAllAtoms ( int modelNo, const ChainID chID, int seqNo, const InsCode insCode ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->DeleteAllAtoms ( chID,seqNo,insCode ); } return 0; } int CMMDBCoorManager::DeleteAllAtoms ( int modelNo, const ChainID chID, int resNo ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->DeleteAllAtoms ( chID,resNo ); } return 0; } int CMMDBCoorManager::DeleteAllAtoms ( int modelNo, const ChainID chID ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->DeleteAllAtoms ( chID ); } return 0; } int CMMDBCoorManager::DeleteAllAtoms ( int modelNo, int chNo, int seqNo, const InsCode insCode ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->DeleteAllAtoms ( chNo,seqNo,insCode ); } return 0; } int CMMDBCoorManager::DeleteAllAtoms ( int modelNo, int chNo, int resNo ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->DeleteAllAtoms ( chNo,resNo ); } return 0; } int CMMDBCoorManager::DeleteAllAtoms ( int modelNo, int chNo ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->DeleteAllAtoms ( chNo ); } return 0; } int CMMDBCoorManager::DeleteAllAtoms ( int modelNo ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->DeleteAllAtoms(); } return 0; } int CMMDBCoorManager::DeleteAllAtoms() { int i,k; k = 0; for (i=0;iDeleteAllAtoms(); return k; } /* int CMMDBCoorManager::DeleteAltLocs() { // This function leaves only alternative location with maximal // occupancy, if those are equal or unspecified, the one with // "least" alternative location indicator. // The function returns the number of deleted atoms and optimizes // the atom index. ChainID chID; ResName rName; InsCode iCode; AtomName aname; AltLoc aLoc,aL; realtype occupancy,occ; int seqNum; int i,j,k,i1,i2,n; k = 0; n = 0; i = 0; while (iGetSeqNum (); occupancy = Atom[i]->GetOccupancy(); strcpy ( chID ,Atom[i]->GetChainID() ); strcpy ( rName,Atom[i]->GetResName() ); strcpy ( iCode,Atom[i]->GetInsCode() ); strcpy ( aname,Atom[i]->name ); strcpy ( aLoc ,Atom[i]->altLoc ); j = i+1; i1 = -1; i2 = i; while (jGetSeqNum()==seqNum) && (!strcmp(Atom[j]->name,aname)) && (!strcmp(Atom[j]->GetInsCode(),iCode)) && (!strcmp(Atom[j]->GetResName(),rName)) && (!strcmp(Atom[j]->GetChainID(),chID ))) { occ = Atom[j]->GetOccupancy(); if (occ>occupancy) { occupancy = occ; i1 = j; } if (aLoc[0]) { strcpy ( aL,Atom[j]->altLoc ); if (!aL[0]) { aLoc[0] = char(0); i2 = j; } else if (strcmp(aL,aLoc)<0) { strcpy ( aLoc,aL ); i2 = j; } } j++; } else break; } else j++; if (i1<0) { if (Atom[i]->WhatIsSet & ASET_Occupancy) i1 = i; else i1 = i2; } while (iindex = k+1; } k++; } } i++; } } else i++; } nAtoms = k; return n; } */ int CMMDBCoorManager::DeleteAltLocs() { // This function leaves only alternative location with maximal // occupancy, if those are equal or unspecified, the one with // "least" alternative location indicator. // The function returns the number of deleted atoms. All tables // remain untrimmed, so that explicit trimming or calling // FinishStructEdit() at some point is required. int i,n; n = 0; for (i=0;iDeleteAltLocs(); return n; } int CMMDBCoorManager::AddAtom ( int modelNo, const ChainID chID, int seqNo, const InsCode insCode, PCAtom atom ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->AddAtom ( chID,seqNo,insCode,atom ); } return 0; } int CMMDBCoorManager::AddAtom ( int modelNo, const ChainID chID, int resNo, PCAtom atom ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->AddAtom ( chID,resNo,atom ); } return 0; } int CMMDBCoorManager::AddAtom ( int modelNo, int chNo, int seqNo, const InsCode insCode, PCAtom atom ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->AddAtom ( chNo,seqNo,insCode,atom ); } return 0; } int CMMDBCoorManager::AddAtom ( int modelNo, int chNo, int resNo, PCAtom atom ) { if ((modelNo>0) && (modelNo<=nModels)) { if (Model[modelNo-1]) return Model[modelNo-1]->AddAtom ( chNo,resNo,atom ); } return 0; } void CMMDBCoorManager::RemoveBricks() { int i,j,k; if (Brick) { for (i=0;ix-xbrick_0)/brick_size); ny = (int)floor((A->y-ybrick_0)/brick_size); nz = (int)floor((A->z-zbrick_0)/brick_size); if ((ny<0) || (nz<0) || (nx>=nbrick_x) || (ny>=nbrick_y) || (nz>=nbrick_z)) nx = -1; } void CMMDBCoorManager::GetBrickCoor ( realtype x, realtype y, realtype z, int & nx, int & ny, int & nz ) { nx = (int)floor((x-xbrick_0)/brick_size); ny = (int)floor((y-ybrick_0)/brick_size); nz = (int)floor((z-zbrick_0)/brick_size); if ((ny<0) || (nz<0) || (nx>=nbrick_x) || (ny>=nbrick_y) || (nz>=nbrick_z)) nx = -1; } void CMMDBCoorManager::GetBrickDimension ( int & nxmax, int & nymax, int & nzmax ) { if (!Brick) { nxmax = 0; nymax = 0; nzmax = 0; } else { nxmax = nbrick_x; nymax = nbrick_y; nzmax = nbrick_z; } } PCBrick CMMDBCoorManager::GetBrick ( int nx, int ny, int nz ) { if (!Brick) return NULL; if ((nx>=0) && (nx=0) && (ny=0) && (nz0) { // find the range of coordinates x1 = MaxReal; x2 = -x1; y1 = MaxReal; y2 = -y1; z1 = MaxReal; z2 = -z1; for (i=0;iTer) && (A[i]->WhatIsSet & ASET_Coordinates)) { if (A[i]->xx; if (A[i]->x>x2) x2 = A[i]->x; if (A[i]->yy; if (A[i]->y>y2) y2 = A[i]->y; if (A[i]->zz; if (A[i]->z>z2) z2 = A[i]->z; } } if (x1Ter) && (A[i]->WhatIsSet & ASET_Coordinates)) { GetBrickCoor ( A[i],nx,ny,nz ); if (nx>=0) { if (!Brick) { Brick = new PPPCBrick[nbrick_x]; for (j=0;jAddAtom ( A[i],i ); } else printf ( " error in " "CMMDBCoorManager::MakeBricks!!!\n" ); } } } } } void CMMDBCoorManager::RemoveMBricks() { int i,j,k; if (MBrick) { for (i=0;ix-xmbrick_0)/mbrick_size); ny = (int)floor((A->y-ymbrick_0)/mbrick_size); nz = (int)floor((A->z-zmbrick_0)/mbrick_size); if ((ny<0) || (nz<0) || (nx>=nmbrick_x) || (ny>=nmbrick_y) || (nz>=nmbrick_z)) nx = -nx-1; } void CMMDBCoorManager::GetMBrickCoor ( realtype x, realtype y, realtype z, int & nx, int & ny, int & nz ) { nx = (int)floor((x-xmbrick_0)/mbrick_size); ny = (int)floor((y-ymbrick_0)/mbrick_size); nz = (int)floor((z-zmbrick_0)/mbrick_size); if ((ny<0) || (nz<0) || (nx>=nmbrick_x) || (ny>=nmbrick_y) || (nz>=nmbrick_z)) nx = -nx-1; } void CMMDBCoorManager::GetMBrickDimension ( int & nxmax, int & nymax, int & nzmax ) { if (!Brick) { nxmax = 0; nymax = 0; nzmax = 0; } else { nxmax = nmbrick_x; nymax = nmbrick_y; nzmax = nmbrick_z; } } PCMBrick CMMDBCoorManager::GetMBrick ( int nx, int ny, int nz ) { if (!MBrick) return NULL; if ((nx>=0) && (nx=0) && (ny=0) && (nzTer) && (A->WhatIsSet & ASET_Coordinates)) { if (A->xx; if (A->x>x2) x2 = A->x; if (A->yy; if (A->y>y2) y2 = A->y; if (A->zz; if (A->z>z2) z2 = A->z; } } } if (x1Ter) && (A->WhatIsSet & ASET_Coordinates)) { GetMBrickCoor ( A,nx,ny,nz ); if (nx>=0) { if (!MBrick) { MBrick = new PPPCMBrick[nmbrick_x]; for (k=0;kAddAtom ( A,i,j ); } else printf ( " error in " "CMMDBCoorManager::MakeMBricks!!!\n" ); } } } } } int CMMDBCoorManager::GenerateSymMates ( PCGenSym GenSym ) { // // The function generates symmetry mates according to symmetry // operations found in GenSym. Results of first symmetry operation // (number 0) always replaces the existing set of atoms, others // are added as additional sets. // If GenSym is set to NULL, the function generates all // symmetry mates for the unit cell taking the symmetry information // from Cryst.SymOps. // The newly generated chains are added to each model. These // chains have many-character chain names, composed as 'x_n', // where 'x' is the original name and 'n' is a unique number, which // coincides with the symmetry operation (order) number; number '_0' // (for the very first symmetry operatyion) is missing. Another // side effect is the disorder in atoms' serial numbers. // The hierarchy should therefore be cleaned after // generating the symmetry mates. An appropriate way to do // that is to issue the following call: // // PDBCleanup ( PDBCLEAN_TER | PDBCLEAN_ALTCODE_STRONG | // PDBCLEAN_CHAIN_STRONG | PDBCLEAN_SERIAL ); // PPCMMDBCoorManager Mate; int i,j,k,n,nMates,nMates1,nAtoms1; PPCAtom Atom1; PPCModel Model1; if (GenSym) nMates = GenSym->GetNofSymOps(); else nMates = Cryst.GetNumberOfSymOps(); if (nMates<=0) return GSM_NoSymOps; if (!Cryst.areMatrices()) return GSM_NoTransfMatrices; if (!Cryst.isCellParameters()) return GSM_NoCell; nMates1 = nMates-1; if (nMates1>0) { // Generate symmetry mates in parallel hierarchies Mate = new PCMMDBCoorManager[nMates1]; for (i=0;iCopy ( this ); Mate[i]->ApplySymTransform ( i+1,GenSym ); } // apply 1st symmetry operation: if (GenSym) ApplySymTransform ( 0,GenSym ); // Gather all symmetry mates in 'this' hierarchy nAtoms1 = nMates*nAtoms; // new number of atoms Atom1 = new PCAtom[nAtoms1]; // new array of atoms if (nModels>0) Model1 = new PCModel[nModels]; // new array of else Model1 = NULL; // models k = 0; // index of collected atoms for (i=0;iSetMMDBManager ( PCMMDBManager(this),i+1 ); for (j=0;jnChains;j++) Model1[i]->MoveChain ( Model[i]->Chain[j],Atom,Atom1,k,0 ); for (n=0;nnChains;j++) Model1[i]->MoveChain ( Mate[n]->Model[i]->Chain[j], Mate[n]->Atom,Atom1,k,n+1 ); } else Model1[i] = NULL; if (Model) delete[] Model; Model = Model1; for (i=0;iTer) Atom[i]->Transform ( TMatrix ); } } void CMMDBCoorManager::ApplySymTransform ( int SymOpNo, PCGenSym GenSym ) { // This procedure applies the symmetry operation number SymOpNo // (starting from 0 on) and renames chains as specified in // GenSym. // The chains don't have to be renamed. The number of chains // to be renamed is obtained as GenSym->nChains[SymOpNo], their // old names - as GenSym->chID1[SymOpNo][j], and their new names // - as GenSym->chID2[SymOpNo][j], 0<=jnChains[SymOpNo]. mat44 tmat; int i,j,k,nChn; PPCChain chain; if (Cryst.GetTMatrix(tmat,SymOpNo,0,0,0,PCSymOps(GenSym)) ==SYMOP_Ok) { for (i=0;iTer) Atom[i]->Transform ( tmat ); } if (GenSym) for (i=0;iGetChainTable ( chain,nChn ); for (j=0;jnChains[SymOpNo];j++) for (k=0;kchainID,GenSym->chID1[SymOpNo][j])) chain[k]->SetChainID ( GenSym->chID2[SymOpNo][j] ); } } } void GetEulerRotMatrix ( mat33 & erm, realtype alpha, realtype beta, realtype gamma ) { // Calculates the Euler rotation matrix for rotation: // 1) about z-axis by angle alpha (0..2*Pi) // 2) about new y-axis by angle beta (0..Pi) // 3) about new z-axis by angle gamma (0..2*Pi) realtype ca,cb,cg, sa,sb,sg; ca = cos(alpha); sa = sin(alpha); cb = cos(beta); sb = sin(beta); cg = cos(gamma); sg = sin(gamma); erm[0][0] = ca*cb*cg - sa*sg; erm[0][1] = cb*cg*sa + ca*sg; erm[0][2] = -cg*sb; erm[1][0] = -cg*sa - ca*cb*sg; erm[1][1] = ca*cg - cb*sa*sg; erm[1][2] = sb*sg; erm[2][0] = ca*sb; erm[2][1] = sa*sb; erm[2][2] = cb; } void GetEulerTMatrix ( mat44 & erm, realtype alpha, realtype beta, realtype gamma, realtype x0, realtype y0, realtype z0 ) { // Calculates the Euler rotation-translation matrix for rotation: // 1) about z-axis by angle alpha // 2) about new y-axis by angle beta // 3) about new z-axis by angle gamma // Point (x0,y0,z0) is the center of rotation. mat33 m; m[0][0] = 1.0; GetEulerRotMatrix ( m,alpha,beta,gamma ); erm[0][0] = m[0][0]; erm[0][1] = m[0][1]; erm[0][2] = m[0][2]; erm[1][0] = m[1][0]; erm[1][1] = m[1][1]; erm[1][2] = m[1][2]; erm[2][0] = m[2][0]; erm[2][1] = m[2][1]; erm[2][2] = m[2][2]; erm[3][0] = 0.0; erm[3][1] = 0.0; erm[3][2] = 0.0; erm[3][3] = 1.0; erm[0][3] = x0 - m[0][0]*x0 - m[0][1]*y0 - m[0][2]*z0; erm[1][3] = y0 - m[1][0]*x0 - m[1][1]*y0 - m[1][2]*z0; erm[2][3] = z0 - m[2][0]*x0 - m[2][1]*y0 - m[2][2]*z0; } void EulerRotation ( PPCAtom A, int nA, realtype alpha, realtype beta, realtype gamma, realtype x0, realtype y0, realtype z0 ) { // Euler rotation: 1) about z-axis by angle alpha // 2) about new y-axis by angle beta // 3) about new z-axis by angle gamma // Point (x0,y0,z0) is the center of rotation. mat33 m; realtype x,y,z; int i; m[0][0] = 1.0; GetEulerRotMatrix ( m,alpha,beta,gamma ); for (i=0;iTer) && (A[i]->WhatIsSet & ASET_Coordinates)) { x = A[i]->x - x0; y = A[i]->y - y0; z = A[i]->z - z0; A[i]->x = m[0][0]*x + m[0][1]*y + m[0][2]*z + x0; A[i]->y = m[1][0]*x + m[1][1]*y + m[1][2]*z + y0; A[i]->z = m[2][0]*x + m[2][1]*y + m[2][2]*z + z0; } } } void GetVecRotMatrix ( mat33 & vrm, realtype alpha, realtype vx, realtype vy, realtype vz ) { // Calculates the rotation matrix for rotation by angle alpha about // arbitrary vector directed as (vx,vy,vz) = (vx2-vx1,vy2-vy1,vz2-vz1). realtype ca,sa, rx,ry,rz, vl; ca = cos(alpha); sa = sin(alpha); vl = sqrt ( vx*vx + vy*vy + vz*vz ); if (vl<=0.0) return; rx = vx/vl; ry = vy/vl; rz = vz/vl; vrm[0][0] = rx*rx*(1.0-ca) + ca; vrm[0][1] = rx*ry*(1.0-ca) - rz*sa; vrm[0][2] = rx*rz*(1.0-ca) + ry*sa; vrm[1][0] = ry*rx*(1.0-ca) + rz*sa; vrm[1][1] = ry*ry*(1.0-ca) + ca; vrm[1][2] = ry*rz*(1.0-ca) - rx*sa; vrm[2][0] = rz*rx*(1.0-ca) - ry*sa; vrm[2][1] = rz*ry*(1.0-ca) + rx*sa; vrm[2][2] = rz*rz*(1.0-ca) + ca; } void GetRotParameters ( mat33 & vrm, realtype & alpha, realtype & vx, realtype & vy, realtype & vz ) { // Given the rotation matrix vrm, GetRotParameters(..) // returns the rotation angle alpha and the normalized // rotation axis vector (vx,vy,vz). // The rotation angle and vector are determined up to // their sign (however correlated, so that being substituted // into GetVecRotMatrix(..) they yield the same rotation // matrix). // The function does not check for vrm to be a valid // rotation matrix. realtype ca,sa,vl; ca = (vrm[0][0]+vrm[1][1]+vrm[2][2]-1.0)/2.0; if (ca<-1.0) ca = -1.0; // does not work if rotation if (ca>1.0) ca = 1.0; // matrix is correct sa = sqrt(1.0-ca*ca); if (sa>0.0) { alpha = acos(ca); // coefficient of 2 is corrected by normalization below vx = (vrm[2][1]-vrm[1][2])/sa; vy = (vrm[0][2]-vrm[2][0])/sa; vz = (vrm[1][0]-vrm[0][1])/sa; // the following code is formally redundant if rotation // matrix is correct, however it eliminates the round-offs vl = sqrt(vx*vx+vy*vy+vz*vz); vx /= vl; vy /= vl; vz /= vl; } else { // zero rotation, arbitrary axis would do alpha = 0.0; vx = 1.0; vy = 0.0; vz = 0.0; } } void GetVecTMatrix ( mat44 & vrm, realtype alpha, realtype vx, realtype vy, realtype vz, realtype x0, realtype y0, realtype z0 ) { // Calculates the rotation-translation matrix for rotation by angle // alpha about arbitrary vector directed as (vx,vy,vz) = // (vx2-vx1,vy2-vy1,vz2-vz1). Point (x0,y0,z0) is the center of // rotation -- actually a point belonging to the rotation axis. mat33 m; GetVecRotMatrix ( m,alpha,vx,vy,vz ); vrm[0][0] = m[0][0]; vrm[0][1] = m[0][1]; vrm[0][2] = m[0][2]; vrm[1][0] = m[1][0]; vrm[1][1] = m[1][1]; vrm[1][2] = m[1][2]; vrm[2][0] = m[2][0]; vrm[2][1] = m[2][1]; vrm[2][2] = m[2][2]; vrm[3][0] = 0.0; vrm[3][1] = 0.0; vrm[3][2] = 0.0; vrm[3][3] = 1.0; vrm[0][3] = x0 - m[0][0]*x0 - m[0][1]*y0 - m[0][2]*z0; vrm[1][3] = y0 - m[1][0]*x0 - m[1][1]*y0 - m[1][2]*z0; vrm[2][3] = z0 - m[2][0]*x0 - m[2][1]*y0 - m[2][2]*z0; } void VectorRotation ( PPCAtom A, int nA, realtype alpha, realtype vx, realtype vy, realtype vz, realtype x0, realtype y0, realtype z0 ) { // Vector rotation is rotation by angle alpha about arbitrary // vector directed as (vx,vy,vz) = (vx2-vx1,vy2-vy1,vz2-vz1). // Point (x0,y0,z0) is the center of rotation -- actually // a point belonging to the rotation axis. mat33 m; realtype x,y,z; int i; GetVecRotMatrix ( m, alpha,vx,vy,vz ); for (i=0;iTer) && (A[i]->WhatIsSet & ASET_Coordinates)) { x = A[i]->x - x0; y = A[i]->y - y0; z = A[i]->z - z0; A[i]->x = m[0][0]*x + m[0][1]*y + m[0][2]*z + x0; A[i]->y = m[1][0]*x + m[1][1]*y + m[1][2]*z + y0; A[i]->z = m[2][0]*x + m[2][1]*y + m[2][2]*z + z0; } } } void GetMassCenter ( PPCAtom A, int nA, realtype & xmc, realtype & ymc, realtype & zmc ) { realtype w,mass; int i,k; xmc = 0.0; ymc = 0.0; zmc = 0.0; mass = 0.0; for (i=0;iTer) && (A[i]->WhatIsSet & ASET_Coordinates)) { k = getElementNo ( A[i]->element ); if (k>=0) w = MolecWeight[k]; else w = 1.0; xmc += w*A[i]->x; ymc += w*A[i]->y; zmc += w*A[i]->z; mass += w; } } if (mass>0.0) { xmc /= mass; ymc /= mass; zmc /= mass; } } int CMMDBCoorManager::BringToUnitCell() { // brings all chains into 0th unit cell PCChain chain; PPCAtom atom; realtype x0,y0,z0, x,y,z, xf,yf,zf, sx,sy,sz; realtype dx,dy,dz, d,d0; int nAtoms; int i,j,k,n,m,nt, ic,jc,kc, is,js,ks; if (!Cryst.areMatrices()) return -1; is = 0; // this is only js = 0; // to depress ks = 0; // "uninitialized" worning Cryst.Frac2Orth ( 0.5,0.5,0.5, x0,y0,z0 ); nt = 0; for (i=0;inChains;j++) { chain = Model[i]->Chain[j]; if (chain) { x = 0.0; y = 0.0; z = 0.0; m = 0; for (k=0;knResidues;k++) if (chain->Residue[k]) { chain->Residue[k]->GetAtomTable ( atom,nAtoms ); for (n=0;nTer) { x += atom[n]->x; y += atom[n]->y; z += atom[n]->z; m++; } } } x /= m; y /= m; z /= m; Cryst.Orth2Frac ( x,y,z, xf,yf,zf ); sx = frac ( xf ); sy = frac ( yf ); sz = frac ( zf ); d0 = MaxReal; for (ic=-3;ic<3;ic++) for (jc=-3;jc<3;jc++) for (kc=-3;kc<3;kc++) { Cryst.Frac2Orth ( sx+ic,sy+jc,sz+kc, dx,dy,dz ); dx -= x0; dy -= y0; dz -= z0; d = dx*dx + dy*dy + dz*dz; if (d1.0e-10) || (fabs(sy)>1.0e-10) || (fabs(sz)>1.0e-10)) { nt++; for (k=0;knResidues;k++) if (chain->Residue[k]) { chain->Residue[k]->GetAtomTable ( atom,nAtoms ); for (n=0;nTer) { Cryst.Orth2Frac ( atom[n]->x,atom[n]->y, atom[n]->z, xf,yf,zf ); Cryst.Frac2Orth ( xf-sx,yf-sy,zf-sz, atom[n]->x,atom[n]->y, atom[n]->z ); } } } } } } } return nt; // number of converted chains } Boolean CMMDBCoorManager::Frac2Orth ( realtype xfrac, realtype yfrac, realtype zfrac, realtype & xorth, realtype & yorth, realtype & zorth ) { return Cryst.Frac2Orth ( xfrac,yfrac,zfrac, xorth,yorth,zorth ); } Boolean CMMDBCoorManager::Orth2Frac ( realtype xorth, realtype yorth, realtype zorth, realtype & xfrac, realtype & yfrac, realtype & zfrac ) { return Cryst.Orth2Frac ( xorth,yorth,zorth, xfrac,yfrac,zfrac ); } Boolean CMMDBCoorManager::Frac2Orth ( mat44 & F, mat44 & T ) { return Cryst.Frac2Orth ( F,T ); } Boolean CMMDBCoorManager::Orth2Frac ( mat44 & T, mat44 & F ) { return Cryst.Orth2Frac ( T,F ); } // ------------------------ Contacts ------------------------------- #define CA_CA_Dist2 16.0 void CMMDBCoorManager::FindSeqSection ( PCAtom atom, int seqDist, int & seq1, int & seq2 ) { PCAtom a; PCResidue res; PCChain chain; realtype x0,y0,z0, x,y,z, dx,dy,dz, d2; int i1; Boolean B0,B; x = 0.0; y = 0.0; z = 0.0; x0 = 0.0; y0 = 0.0; z0 = 0.0; res = atom->residue; if ((!res) || (seqDist<=0)) { seq1 = MaxInt4; seq2 = MinInt4; return; } chain = res->chain; if (!chain) { seq1 = MaxInt4; seq2 = MinInt4; return; } if (seqDist==1) { seq1 = res->index; seq2 = seq1; return; } a = res->GetAtom ( pstr("CA"),pstr("C"),NULL ); if (a) { x0 = a->x; y0 = a->y; z0 = a->z; B0 = True; } else B0 = False; if (B0) { x = x0; y = y0; z = z0; } B = B0; seq2 = res->index; i1 = IMin(chain->nResidues,seq2+seqDist)-1; while (seq2Residue[seq2]) { a = chain->Residue[seq2]->GetAtom ( pstr("CA"),pstr("C"),NULL ); if (a && B) { dx = x-a->x; dy = y-a->y; dz = z-a->z; d2 = dx*dx + dy*dy + dz*dz; if (d2>CA_CA_Dist2) { seq2--; break; } } if (a) { x = a->x; y = a->y; z = a->z; B = True; } else B = False; } } if (B0) { x = x0; y = y0; z = z0; } B = B0; seq1 = res->index; i1 = IMax(0,seq1-seqDist+1); while (seq1>i1) { seq1--; if (chain->Residue[seq1]) { a = chain->Residue[seq1]->GetAtom ( pstr("CA"),pstr("C"),NULL ); if (a && B) { dx = x-a->x; dy = y-a->y; dz = z-a->z; d2 = dx*dx + dy*dy + dz*dz; if (d2>CA_CA_Dist2) { seq1++; break; } } if (a) { x = a->x; y = a->y; z = a->z; B = True; } else B = False; } } } Boolean CMMDBCoorManager::isContact ( PCAtom a1, PCAtom a2, int seq1, int seq2, realtype dd, realtype d12, realtype d22, realtype & d2 ) { // seq1..seq2 is forbidden region for residue sequence numbers PCResidue res1,res2; PCChain chain1,chain2; realtype dx,dy,dz; if (a2->Ter) return False; dx = fabs(a2->x-a1->x); if (dx<=dd) { dy = fabs(a2->y-a1->y); if (dy<=dd) { dz = fabs(a2->z-a1->z); if (dz<=dd) { d2 = dx*dx + dy*dy + dz*dz; if ((d12<=d2) && (d2<=d22)) { if (seq1<=seq2) { res1 = a1->residue; res2 = a2->residue; if (res1 && res2) { chain1 = res1->chain; chain2 = res2->chain; if (chain1 && chain2) { if (!strcmp(chain1->chainID,chain2->chainID)) { if ((seq1<=res2->index) && (res2->index<=seq2)) return False; } } } } return True; } } } } return False; } Boolean CMMDBCoorManager::isContact ( realtype x, realtype y, realtype z, PCAtom a2, realtype dd, realtype d12, realtype d22, realtype & d2 ) { realtype dx,dy,dz; if (a2->Ter) return False; dx = fabs(a2->x-x); if (dx<=dd) { dy = fabs(a2->y-y); if (dy<=dd) { dz = fabs(a2->z-z); if (dz<=dd) { d2 = dx*dx + dy*dy + dz*dz; if ((d12<=d2) && (d2<=d22)) return True; } } } return False; } void CMMDBCoorManager::SeekContacts ( PPCAtom AIndex, int ilen, int atomNum, realtype dist1, realtype dist2, int seqDist, RPSContact contact, int & ncontacts, int maxlen, long group ) { PCContactIndex ContactIndex; realtype d12,d22,d2; int i,seq1,seq2; if (!AIndex) return; if (dist2Ter) return; ContactIndex = new CContactIndex ( contact,maxlen,ncontacts,ilen ); FindSeqSection ( AIndex[atomNum],seqDist,seq1,seq2 ); d12 = dist1*dist1; d22 = dist2*dist2; for (i=0;iAddContact ( atomNum,i,sqrt(d2),group ); } ContactIndex->GetIndex ( contact,ncontacts ); delete ContactIndex; } void CMMDBCoorManager::SeekContacts ( PCAtom A, PPCAtom AIndex, int ilen, realtype dist1, realtype dist2, int seqDist, RPSContact contact, int & ncontacts, int maxlen, long group ) { PCContactIndex ContactIndex; realtype d12,d22,d2; int i,seq1,seq2; if (!AIndex) return; if (dist2Ter) return; ContactIndex = new CContactIndex ( contact,maxlen,ncontacts,ilen ); FindSeqSection ( A,seqDist,seq1,seq2 ); d12 = dist1*dist1; d22 = dist2*dist2; for (i=0;iAddContact ( -1,i,sqrt(d2),group ); } ContactIndex->GetIndex ( contact,ncontacts ); delete ContactIndex; } void CMMDBCoorManager::SeekContacts ( PPCAtom AIndex1, int ilen1, PPCAtom AIndex2, int ilen2, realtype dist1, realtype dist2, int seqDist, RPSContact contact, int & ncontacts, int maxlen, mat44 * TMatrix, long group, int bricking, Boolean doSqrt ) { // It is Ok to have NULL pointers in AIndex1 and AIndex2 PCContactIndex ContactIndex; PPCAtom A1,A2; rvector sx0,sy0,sz0; rvector dx0,dy0,dz0; realtype d12,d22,d2, eps; int l1,l2, i,j, nx,ny,nz, dn; int ix1,ix2, iy1,iy2, iz1,iz2, ix,iy,iz; int seq1,seq2; PCBrick B; Boolean swap,UnitT; if ((dist2x; sy0[i] = AIndex1[i]->y; sz0[i] = AIndex1[i]->z; } // Save original AIndex2 coordinates and modify the index GetVectorMemory ( dx0,ilen2,0 ); GetVectorMemory ( dy0,ilen2,0 ); GetVectorMemory ( dz0,ilen2,0 ); for (i=0;ix; dy0[i] = AIndex2[i]->y; dz0[i] = AIndex2[i]->z; AIndex2[i]->Transform ( *TMatrix ); } } } // choose A2 as the largest atom set convenient for // bricking (bricking on larger set is more efficient) if (bricking & BRICK_ON_1) { A1 = AIndex2; A2 = AIndex1; l1 = ilen2; l2 = ilen1; swap = True; } else if (bricking & BRICK_ON_2) { A1 = AIndex1; A2 = AIndex2; l1 = ilen1; l2 = ilen2; swap = False; } else if (ilen1<=ilen2) { A1 = AIndex1; A2 = AIndex2; l1 = ilen1; l2 = ilen2; swap = False; } else { A1 = AIndex2; A2 = AIndex1; l1 = ilen2; l2 = ilen1; swap = True; } d12 = dist1*dist1; d22 = dist2*dist2; if (((bricking & BRICK_READY)==0) || (!Brick)) MakeBricks ( A2,l2,dist2*1.5 ); dn = mround(dist2/brick_size)+1; if (Brick) for (i=0;iTer) { if (UnitT) { // No transformation -- AIndex1 and AIndex2 are unmodified. // Calculate the forbidden sequence region FindSeqSection ( A1[i],seqDist,seq1,seq2 ); // And the brick location GetBrickCoor ( A1[i],nx,ny,nz ); } else { // AIndex2 and AIndex1 are modified, but the sequence // distance does not apply to physically different chains // (meaning that transformation of A2 effectively makes // a different chain). Use unmodified atom coordinates // of 1st set for calculating the brick location. if (swap) GetBrickCoor ( A1[i],nx,ny,nz ); // A1 is AIndex2 else GetBrickCoor ( sx0[i],sy0[i],sz0[i],nx,ny,nz ); } if (nx>=0) { ix1 = IMax ( 0,nx-dn ); iy1 = IMax ( 0,ny-dn ); iz1 = IMax ( 0,nz-dn ); ix2 = IMin ( nbrick_x,nx+dn+1 ); iy2 = IMin ( nbrick_y,ny+dn+1 ); iz2 = IMin ( nbrick_z,nz+dn+1 ); if (UnitT) { // AIndex1 unmodified, use it for (ix=ix1;ixnAtoms;j++) if (B->Atom[j]!=A1[i]) { if (isContact(A1[i],B->Atom[j],seq1,seq2, dist2,d12,d22,d2)) { if (doSqrt) d2 = sqrt(d2); if (swap) ContactIndex->AddContact ( B->id[j],i,d2,group ); else ContactIndex->AddContact ( i,B->id[j],d2,group ); } } } } else if (swap) { // A1 stands for AIndex2, it is modified and we need to use // the modified coordinates for (ix=ix1;ixnAtoms;j++) if (isContact(A1[i]->x,A1[i]->y,A1[i]->z, B->Atom[j], dist2,d12,d22,d2)) { if (doSqrt) d2 = sqrt(d2); ContactIndex->AddContact ( B->id[j],i,d2,group ); } } } else { // A1 stands for AIndex1, it may be modified (if AIndex1 // and AIndex2 overlap) -- use its unmodified coordinates // instead. for (ix=ix1;ixnAtoms;j++) if (isContact(sx0[i],sy0[i],sz0[i], B->Atom[j],dist2,d12,d22,d2)) { if (doSqrt) d2 = sqrt(d2); ContactIndex->AddContact ( i,B->id[j],d2,group ); } } } } } } if (!UnitT) { // restore original coordinates for (i=0;ix = sx0[i]; AIndex1[i]->y = sy0[i]; AIndex1[i]->z = sz0[i]; } for (i=0;ix = dx0[i]; AIndex2[i]->y = dy0[i]; AIndex2[i]->z = dz0[i]; } FreeVectorMemory ( sx0,0 ); FreeVectorMemory ( sy0,0 ); FreeVectorMemory ( sz0,0 ); FreeVectorMemory ( dx0,0 ); FreeVectorMemory ( dy0,0 ); FreeVectorMemory ( dz0,0 ); } ContactIndex->GetIndex ( contact,ncontacts ); delete ContactIndex; } void CMMDBCoorManager::SeekContacts ( PPCAtom AIndex1, int ilen1, PPCAtom AIndex2, int ilen2, realtype contDist, PSContact contact, int & ncontacts, int bricking ) { // Simplified optimized for speed version: // - no NULL pointers and Ters in AIndex1 and AIndex2 // - no checks for identity atoms in AIndex1 and AIndex2 // - contact must be pre-allocated with at least ilen1*ilen2 elements // - contact returns square distances // - ncontacts is always reset PPCAtom A1,A2; realtype contDist2, dx,dy,dz, d2; int l1,l2, i,j, nx,ny,nz, dn; int ix1,ix2, iy1,iy2, iz1,iz2, ix,iy,iz; PCBrick B; Boolean swap; // choose A2 as the largest atom set convenient for // bricking (bricking on larger set is more efficient) if (bricking & BRICK_ON_1) { A1 = AIndex2; A2 = AIndex1; l1 = ilen2; l2 = ilen1; swap = True; } else if (bricking & BRICK_ON_2) { A1 = AIndex1; A2 = AIndex2; l1 = ilen1; l2 = ilen2; swap = False; } else if (ilen1<=ilen2) { A1 = AIndex1; A2 = AIndex2; l1 = ilen1; l2 = ilen2; swap = False; } else { A1 = AIndex2; A2 = AIndex1; l1 = ilen2; l2 = ilen1; swap = True; } contDist2 = contDist*contDist; if (((bricking & BRICK_READY)==0) || (!Brick)) MakeBricks ( A2,l2,contDist*1.5 ); ncontacts = 0; if (!Brick) return; dn = (int)floor(contDist/brick_size)+1; if (swap) { for (i=0;i=0) { ix1 = IMax ( 0,nx-dn ); iy1 = IMax ( 0,ny-dn ); iz1 = IMax ( 0,nz-dn ); ix2 = IMin ( nbrick_x,nx+dn+1 ); iy2 = IMin ( nbrick_y,ny+dn+1 ); iz2 = IMin ( nbrick_z,nz+dn+1 ); for (ix=ix1;ixnAtoms;j++) { dx = A1[i]->x - B->Atom[j]->x; dy = A1[i]->y - B->Atom[j]->y; dz = A1[i]->z - B->Atom[j]->z; d2 = dx*dx + dy*dy + dz*dz; if (d2<=contDist2) { contact[ncontacts].id1 = B->id[j]; contact[ncontacts].id2 = i; contact[ncontacts].dist = d2; ncontacts++; } } } } } } else { for (i=0;i=0) { ix1 = IMax ( 0,nx-dn ); iy1 = IMax ( 0,ny-dn ); iz1 = IMax ( 0,nz-dn ); ix2 = IMin ( nbrick_x,nx+dn+1 ); iy2 = IMin ( nbrick_y,ny+dn+1 ); iz2 = IMin ( nbrick_z,nz+dn+1 ); for (ix=ix1;ixnAtoms;j++) { dx = A1[i]->x - B->Atom[j]->x; dy = A1[i]->y - B->Atom[j]->y; dz = A1[i]->z - B->Atom[j]->z; d2 = dx*dx + dy*dy + dz*dz; if (d2<=contDist2) { contact[ncontacts].id1 = i; contact[ncontacts].id2 = B->id[j]; contact[ncontacts].dist = d2; ncontacts++; } } } } } } } void CMMDBCoorManager::SeekContacts ( PPCAtom AIndex1, int ilen1, PPCAtom * AIndex2, ivector ilen2, int nStructures, realtype dist1, realtype dist2, PPCMContact & contact, int bricking ) { // It is Ok to have NULL pointers in AIndex1 and AIndex2 PCMBrick B; PCAtom A; realtype d12,d22,d2; int dn, i,j,k, nx,ny,nz, ix1,iy1,iz1, ix2,iy2,iz2; int ix,iy,iz; if (dist2Ter) { contact[i] = new CMContact(nStructures); contact[i]->contactID = i; // Calculate the brick location GetMBrickCoor ( A,nx,ny,nz ); if (nx>=0) { ix1 = IMax ( 0,nx-dn ); iy1 = IMax ( 0,ny-dn ); iz1 = IMax ( 0,nz-dn ); ix2 = IMin ( nmbrick_x,nx+dn+1 ); iy2 = IMin ( nmbrick_y,ny+dn+1 ); iz2 = IMin ( nmbrick_z,nz+dn+1 ); for (ix=ix1;ixnAtoms[j];k++) if (B->Atom[j][k]!=A) { if (isContact(A,B->Atom[j][k], MaxInt4,MinInt4, dist2,d12,d22,d2)) contact[i]->AddContact ( B->Atom[j][k],j,B->id[j][k] ); } } } } } } else for (i=0;i ((PSContact)data)[j].id1); lt = (((PSContact)data)[i].id1 < ((PSContact)data)[j].id1); break; case CNSORT_1DEC : gt = (((PSContact)data)[j].id1 > ((PSContact)data)[i].id1); lt = (((PSContact)data)[j].id1 < ((PSContact)data)[i].id1); break; case CNSORT_2INC : gt = (((PSContact)data)[i].id2 > ((PSContact)data)[j].id2); lt = (((PSContact)data)[i].id2 < ((PSContact)data)[j].id2); break; case CNSORT_2DEC : gt = (((PSContact)data)[j].id2 > ((PSContact)data)[i].id2); lt = (((PSContact)data)[j].id2 < ((PSContact)data)[i].id2); break; case CNSORT_DINC : gt = (((PSContact)data)[i].dist > ((PSContact)data)[j].dist); lt = (((PSContact)data)[i].dist < ((PSContact)data)[j].dist); break; case CNSORT_DDEC : gt = (((PSContact)data)[j].dist > ((PSContact)data)[i].dist); lt = (((PSContact)data)[j].dist < ((PSContact)data)[i].dist); break; } if (gt) return 1; if (lt) return -1; return 0; } void CSortContacts::Swap ( int i, int j ) { ((PSContact)data)[i].Swap ( ((PSContact)data)[j] ); } void CSortContacts::Sort ( PSContact contact, int ncontacts, int sortmode ) { mode = sortmode; if (mode!=CNSORT_OFF) CQuickSort::Sort ( &(contact[0]),ncontacts ); } void SortContacts ( PSContact contact, int ncontacts, int sortmode ) { CSortContacts SC; if (sortmode!=CNSORT_OFF) SC.Sort ( contact,ncontacts,sortmode ); } // ------------------- Stream functions ---------------------- void CMMDBCoorManager::write ( RCFile f ) { byte Version=1; f.WriteByte ( &Version ); CMMDBFile::write ( f ); f.WriteInt ( &CoorIDCode ); f.WriteReal ( &brick_size ); f.WriteReal ( &xbrick_0 ); f.WriteReal ( &ybrick_0 ); f.WriteReal ( &zbrick_0 ); f.WriteInt ( &nbrick_x ); f.WriteInt ( &nbrick_y ); f.WriteInt ( &nbrick_z ); } void CMMDBCoorManager::read ( RCFile f ) { byte Version; f.ReadByte ( &Version ); CMMDBFile::read ( f ); f.ReadInt ( &CoorIDCode ); f.ReadReal ( &brick_size ); f.ReadReal ( &xbrick_0 ); f.ReadReal ( &ybrick_0 ); f.ReadReal ( &zbrick_0 ); f.ReadInt ( &nbrick_x ); f.ReadInt ( &nbrick_y ); f.ReadInt ( &nbrick_z ); } MakeStreamFunctions(CMMDBCoorManager); // =================================================================== int SuperposeAtoms ( mat44 & T, PPCAtom A1, int nA, PPCAtom A2, ivector C ) { realtype xc1,yc1,zc1, xc2,yc2,zc2, det,B; rmatrix A,U,V; rvector W,RV1; vect3 vc1,vc2; int i,j,k,i1,i2,nat; // 1. Set unit matrix as "default" return for (i=0;i<4;i++) { for (j=0;j<4;j++) T[i][j] = 0.0; T[i][i] = 1.0; } // 2. Calculate mass centers xc1 = 0.0; yc1 = 0.0; zc1 = 0.0; xc2 = 0.0; yc2 = 0.0; zc2 = 0.0; nat = 0; if (C) { for (i1=0;i1Ter) { i2 = C[i1]; if (i2>=0) { xc1 += A1[i1]->x; yc1 += A1[i1]->y; zc1 += A1[i1]->z; xc2 += A2[i2]->x; yc2 += A2[i2]->y; zc2 += A2[i2]->z; nat++; } } } else { for (i=0;iTer) && (!A2[i]->Ter)) { xc1 += A1[i]->x; yc1 += A1[i]->y; zc1 += A1[i]->z; xc2 += A2[i]->x; yc2 += A2[i]->y; zc2 += A2[i]->z; nat++; } } if (nat>1) { xc1 /= nat; yc1 /= nat; zc1 /= nat; xc2 /= nat; yc2 /= nat; zc2 /= nat; } else if (nat>0) { T[0][3] = xc2 - xc1; T[1][3] = yc2 - yc1; T[2][3] = zc2 - zc1; return SPOSEAT_Ok; } else return SPOSEAT_NoAtoms; // 3. Calculate the correlation matrix GetMatrixMemory ( A,3,3,1,1 ); for (i=1;i<=3;i++) for (j=1;j<=3;j++) A[i][j] = 0.0; if (C) { for (i1=0;i1Ter) { i2 = C[i1]; if (i2>=0) { vc1[0] = A1[i1]->x - xc1; vc1[1] = A1[i1]->y - yc1; vc1[2] = A1[i1]->z - zc1; vc2[0] = A2[i2]->x - xc2; vc2[1] = A2[i2]->y - yc2; vc2[2] = A2[i2]->z - zc2; for (i=1;i<=3;i++) for (j=1;j<=3;j++) A[i][j] += vc1[j-1]*vc2[i-1]; } } } else { for (k=0;kTer) && (!A2[k]->Ter)) { vc1[0] = A1[k]->x - xc1; vc1[1] = A1[k]->y - yc1; vc1[2] = A1[k]->z - zc1; vc2[0] = A2[k]->x - xc2; vc2[1] = A2[k]->y - yc2; vc2[2] = A2[k]->z - zc2; for (i=1;i<=3;i++) for (j=1;j<=3;j++) A[i][j] += vc1[j-1]*vc2[i-1]; } } // 4. Calculate transformation matrix (to be applied to A1) det = A[1][1]*A[2][2]*A[3][3] + A[1][2]*A[2][3]*A[3][1] + A[2][1]*A[3][2]*A[1][3] - A[1][3]*A[2][2]*A[3][1] - A[1][1]*A[2][3]*A[3][2] - A[3][3]*A[1][2]*A[2][1]; // 4.1 SV-decompose the correlation matrix GetMatrixMemory ( U ,3,3,1,1 ); GetMatrixMemory ( V ,3,3,1,1 ); GetVectorMemory ( W ,3,1 ); GetVectorMemory ( RV1,3,1 ); SVD ( 3,3,3,A,U,V,W,RV1,True,True,i ); if (i!=0) { FreeVectorMemory ( RV1,1 ); FreeVectorMemory ( W ,1 ); FreeMatrixMemory ( V ,3,1,1 ); FreeMatrixMemory ( U ,3,1,1 ); FreeMatrixMemory ( A ,3,1,1 ); return SPOSEAT_SVD_Fail; } // 4.2 Check for parasite inversion and fix it if found if (det<=0.0) { k = 0; B = MaxReal; for (j=1;j<=3;j++) if (W[j]x - A[1]->x; U[1] = A[0]->y - A[1]->y; U[2] = A[0]->z - A[1]->z; W[0] = A[2]->x - A[1]->x; W[1] = A[2]->y - A[1]->y; W[2] = A[2]->z - A[1]->z; V[0] = A[3]->x - A[2]->x; V[1] = A[3]->y - A[2]->y; V[2] = A[3]->z - A[2]->z; a[0] = U[1]*W[2] - W[1]*U[2]; a[1] = U[2]*W[0] - W[2]*U[0]; a[2] = U[0]*W[1] - W[0]*U[1]; b[0] = V[1]*W[2] - W[1]*V[2]; b[1] = V[2]*W[0] - W[2]*V[0]; b[2] = V[0]*W[1] - W[0]*V[1]; c[0] = a[1]*b[2] - b[1]*a[2]; c[1] = a[2]*b[0] - b[2]*a[0]; c[2] = a[0]*b[1] - b[0]*a[1]; Wmag = sqrt(W[0]*W[0]+W[1]*W[1]+W[2]*W[2]); S = c[0]*W[0] + c[1]*W[1] + c[2]*W[2]; T = a[0]*b[0] + a[1]*b[1] + a[2]*b[2]; T *= Wmag; if ((S==0.0) && (T==0.0)) return NO_TORSION; else return atan2(S,T); } realtype getPsi ( PPCAtom A ) { vect3 v1,v2; realtype l1,l2; v1[0] = A[0]->x - A[1]->x; v1[1] = A[0]->y - A[1]->y; v1[2] = A[0]->z - A[1]->z; v2[0] = A[2]->x - A[1]->x; v2[1] = A[2]->y - A[1]->y; v2[2] = A[2]->z - A[1]->z; l1 = v1[0]*v1[0] + v1[1]*v1[1] + v1[2]*v1[2]; if (l1==0.0) l1 = 1.0; l2 = v2[0]*v2[0] + v2[1]*v2[1] + v2[2]*v2[2]; if (l2==0.0) l2 = 1.0; return acos((v1[0]*v2[0]+v1[1]*v2[1]+v1[2]*v2[2])/sqrt(l1*l2)); } mmdb-1.25.5/mmdb/machine_.cpp0000775000175000017500000001100411736610510012633 00000000000000// $Id: machine_.cpp,v 1.21 2012/01/26 17:52:19 ekr Exp $ // ================================================================= // // CCP4 Coordinate Library: support of coordinate-related // functionality in protein crystallography applications. // // Copyright (C) Eugene Krissinel 2000-2008. // // This library is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // // ================================================================= // // 08.07.08 <-- Date of Last Modification. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ----------------------------------------------------------------- // // **** Module : machine_ // ~~~~~~~~~ // **** Functions : GetMachineID - returns ID code for the machine // ~~~~~~~~~~~ GetMachineName - returns name of a machine // // (C) E. Krissinel 2000-2008 // // ================================================================= // #ifndef __Machine__ #include "machine_.h" #endif #ifdef CALL_LIKE_SUN int GetMachineID() { int k = CALL_LIKE_SUN; switch (k) { case 1 : return MACHINE_ALLIANT; case 2 : return MACHINE_CONVEX; case 3 : return MACHINE_ESV; case 4 : return MACHINE_SGI; case 5 : return MACHINE_SOLBOURNE; case 6 : return MACHINE_SOLARIS; case 7 : return MACHINE_ALPHA; case 8 : return MACHINE_F2C_G77; case 9 : return MACHINE_LINUX; default : return MACHINE_UNKNOWN; } } #elif defined(CALL_LIKE_HPUX) int GetMachineID() { int k = CALL_LIKE_HPUX; switch (k) { case 1 : return MACHINE_RS6000; case 2 : return MACHINE_HP9000; default : return MACHINE_UNKNOWN; } } #elif defined(CALL_LIKE_STARDENT) int GetMachineID() { int k = CALL_LIKE_STARDENT; switch (k) { case 1 : return MACHINE_ARDENT; case 2 : return MACHINE_TITAN; case 3 : return MACHINE_STARDENT; default : return MACHINE_UNKNOWN; } } #elif defined(CALL_LIKE_VMS) int GetMachineID() { return MACHINE_VMS; } #elif defined(CALL_LIKE_MVS) int GetMachineID() { return MACHINE_MVS; } #else int GetMachineID() { return MACHINE_UNKNOWN; } #endif static cpstr MCH_SGI = cpstr("Silicon Graphics"); static cpstr MCH_RS6000 = cpstr("IBM RS/6000"); static cpstr MCH_ALLIANT = cpstr("Alliant"); static cpstr MCH_ARDENT = cpstr("Ardent"); static cpstr MCH_TITAN = cpstr("Titan"); static cpstr MCH_STARDENT = cpstr("Stardent"); static cpstr MCH_CONVEX = cpstr("Convex"); static cpstr MCH_ESV = cpstr("Evans or Sutherland"); static cpstr MCH_HP9000 = cpstr("Hewlett Packard 9000"); static cpstr MCH_SOLBOURNE = cpstr("Solbourne"); static cpstr MCH_SOLARIS = cpstr("Solaris"); static cpstr MCH_ALPHA = cpstr("DEC Alpha"); static cpstr MCH_VMS = cpstr("A VMS machine"); static cpstr MCH_MVS = cpstr("MS Windows"); static cpstr MCH_F2C_G77 = cpstr("SUN compatible"); static cpstr MCH_LINUX = cpstr("Linux"); cpstr GetMachineName ( int MachineID ) { switch (MachineID) { case MACHINE_SGI : return MCH_SGI; case MACHINE_RS6000 : return MCH_RS6000; case MACHINE_ALLIANT : return MCH_ALLIANT; case MACHINE_ARDENT : return MCH_ARDENT; case MACHINE_TITAN : return MCH_TITAN; case MACHINE_STARDENT : return MCH_STARDENT; case MACHINE_CONVEX : return MCH_CONVEX; case MACHINE_ESV : return MCH_ESV; case MACHINE_HP9000 : return MCH_HP9000; case MACHINE_SOLBOURNE : return MCH_SOLBOURNE; case MACHINE_SOLARIS : return MCH_SOLARIS; case MACHINE_ALPHA : return MCH_ALPHA; case MACHINE_VMS : return MCH_VMS; case MACHINE_MVS : return MCH_MVS; case MACHINE_F2C_G77 : return MCH_F2C_G77; case MACHINE_LINUX : return MCH_LINUX; default : case MACHINE_UNKNOWN : return pstr("Unidentified machine"); } } cpstr GetMachineName() { return GetMachineName ( GetMachineID() ); } mmdb-1.25.5/mmdb/mmdb_title.cpp0000775000175000017500000017675212162051331013230 00000000000000// $Id: mmdb_title.cpp,v 1.26 2012/01/26 17:52:21 ekr Exp $ // ================================================================= // // CCP4 Coordinate Library: support of coordinate-related // functionality in protein crystallography applications. // // Copyright (C) Eugene Krissinel 2000-2008. // // This library is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // // ================================================================= // // 23.06.13 <-- Date of Last Modification. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ----------------------------------------------------------------- // // **** Module : MMDB_Title // ~~~~~~~~~ // **** Project : MacroMolecular Data Base (MMDB) // ~~~~~~~~~ // **** Classes : CTitleContainer (container for title classes) // ~~~~~~~~~ CObsLine // CTitleLine // CCaveat // CCompound // CSource // CKeyWords // CExpData // CMdlType // CAuthor // CRevData // CSupersede // CJournal // CRemark // CBiomolecule // CMMDBTitle ( MMDB title section ) // // (C) E. Krissinel 2000-2013 // // ================================================================= // #ifndef __STRING_H #include #endif #ifndef __STDLIB_H #include #endif #ifndef __MMDB_Title__ #include "mmdb_title.h" #endif #ifndef __MMDB_CIFDefs__ #include "mmdb_cifdefs.h" #endif // ============== CTitleContainer ==================== PCContainerClass CTitleContainer::MakeContainerClass ( int ClassID ) { switch (ClassID) { default : case ClassID_Template : return CClassContainer::MakeContainerClass(ClassID); case ClassID_ObsLine : return new CObsLine (); case ClassID_CAVEAT : return new CCaveat (); case ClassID_TitleLine : return new CTitleLine(); case ClassID_Compound : return new CCompound (); case ClassID_Source : return new CSource (); case ClassID_ExpData : return new CExpData (); case ClassID_Author : return new CAuthor (); case ClassID_RevData : return new CRevData (); case ClassID_Supersede : return new CSupersede(); case ClassID_Journal : return new CJournal (); case ClassID_Remark : return new CRemark (); } } MakeStreamFunctions(CTitleContainer) // ================ CObsLine =================== CObsLine::CObsLine() : CContainerClass() { InitObsLine(); } CObsLine::CObsLine ( cpstr S ) : CContainerClass() { InitObsLine(); ConvertPDBASCII ( S ); } CObsLine::CObsLine ( RPCStream Object ) : CContainerClass(Object) { InitObsLine(); } CObsLine::~CObsLine() {} void CObsLine::InitObsLine() { int i; strcpy ( repDate,"DD-MMM-YYYY" ); strcpy ( idCode, "----" ); for (i=0;i<8;i++) strcpy ( rIdCode[i]," " ); } void CObsLine::PDBASCIIDump ( pstr S, int N ) { // makes the ASCII PDB OBSLTE line number N // from the class' data int i; if (N==0) strcpy ( S,"OBSLTE " ); else sprintf ( S,"OBSLTE %2i",N+1 ); PadSpaces ( S,80 ); Date11to9 ( repDate,&(S[11]) ); strncpy ( &(S[21]),idCode,4 ); for (i=0;i<8;i++) strncpy ( &(S[31+5*i]),rIdCode[i],4 ); } void CObsLine::MakeCIF ( PCMMCIFData CIF, int ) { PCMMCIFLoop Loop; int RC,i,j; char DateCIF[20]; RC = CIF->AddLoop ( CIFCAT_OBSLTE,Loop ); if (RC!=CIFRC_Ok) { // the category was (re)created, provide tags Loop->AddLoopTag ( CIFTAG_ID ); Loop->AddLoopTag ( CIFTAG_DATE ); Loop->AddLoopTag ( CIFTAG_REPLACE_PDB_ID ); Loop->AddLoopTag ( CIFTAG_PDB_ID ); } Date11toCIF ( repDate,DateCIF ); for (i=0;i<8;i++) { j = 0; while (rIdCode[i][j] && (rIdCode[i][j]==' ')) j++; if (rIdCode[i][j]) { Loop->AddString ( pstr("OBSLTE") ); Loop->AddString ( DateCIF ); Loop->AddString ( idCode ); Loop->AddString ( rIdCode[i] ); } } } int CObsLine::ConvertPDBASCII ( cpstr S ) { int i; Date9to11 ( &(S[11]),repDate ); strncpy ( idCode,&(S[21]),4 ); idCode[4] = char(0); for (i=0;i<8;i++) { strncpy ( rIdCode[i],&(S[31+i*5]),4 ); rIdCode[i][4] = char(0); } return 0; } void CObsLine::GetCIF ( PCMMCIFData CIF, int & Signal ) { PCMMCIFLoop Loop; int i,RC; pstr F,FDate,FID; char DateCIF [20]; char DateCIF0[20]; IDCode idCode1; Loop = CIF->GetLoop ( CIFCAT_OBSLTE ); if (!Loop) { Signal = -1; // signal to finish processing of this structure return; } i = 0; do { F = Loop->GetString ( CIFTAG_ID,Signal,RC ); if (RC) { if (i==0) Signal = -1; return; } if (F) { if (!strcmp(F,"OBSLTE")) { FDate = Loop->GetString ( CIFTAG_DATE,Signal,RC ); if ((!RC) && FDate) strncpy ( DateCIF,FDate,15 ); else strcpy ( DateCIF,"YYYY-MMM-DD" ); FID = Loop->GetString ( CIFTAG_REPLACE_PDB_ID,Signal,RC ); if ((!RC) && FID) strncpy ( idCode1,FID,sizeof(IDCode)-1 ); else idCode1[0] = char(0); if (i==0) { DateCIFto11 ( DateCIF,repDate ); DateCIF[11] = char(0); strcpy ( idCode ,idCode1 ); strcpy ( DateCIF0,DateCIF ); } else if ((strcmp(DateCIF0,DateCIF)) || (strcmp(idCode,idCode1))) return; FID = Loop->GetString ( CIFTAG_PDB_ID,Signal,RC ); if ((!RC) && FID) strncpy ( rIdCode[i],FID,sizeof(IDCode)-1 ); else rIdCode[i][0] = char(0); Loop->DeleteField ( CIFTAG_ID ,Signal ); Loop->DeleteField ( CIFTAG_DATE ,Signal ); Loop->DeleteField ( CIFTAG_REPLACE_PDB_ID,Signal ); Loop->DeleteField ( CIFTAG_PDB_ID ,Signal ); i++; } } Signal++; } while (i<8); } void CObsLine::Copy ( PCContainerClass ObsLine ) { int i; strcpy ( repDate,PCObsLine(ObsLine)->repDate ); strcpy ( idCode ,PCObsLine(ObsLine)->idCode ); for (i=0;i<8;i++) strcpy ( rIdCode[i],PCObsLine(ObsLine)->rIdCode[i] ); } void CObsLine::write ( RCFile f ) { int i; byte Version=1; f.WriteByte ( &Version ); f.WriteTerLine ( repDate,False ); f.WriteTerLine ( idCode ,False ); for (i=0;i<8;i++) f.WriteTerLine ( rIdCode[i],False ); } void CObsLine::read ( RCFile f ) { int i; byte Version; f.ReadByte ( &Version ); f.ReadTerLine ( repDate,False ); f.ReadTerLine ( idCode ,False ); for (i=0;i<8;i++) f.ReadTerLine ( rIdCode[i],False ); } MakeStreamFunctions(CObsLine) // =================== CTitleLine ====================== CTitleLine::CTitleLine() : CContString() { InitTitleLine(); } CTitleLine::CTitleLine ( cpstr S ) : CContString() { InitTitleLine(); ConvertPDBASCII ( S ); } CTitleLine::CTitleLine ( RPCStream Object ) : CContString(Object) { InitTitleLine(); } CTitleLine::~CTitleLine() { } void CTitleLine::InitTitleLine() { CreateCopy ( CIFCategory,CIFCAT_STRUCT ); CreateCopy ( CIFTag, CIFTAG_TITLE ); } int CTitleLine::ConvertPDBASCII ( cpstr S ) { if (strlen(S)>10) CreateCopy ( Line,&(S[10]) ); else CreateCopy ( Line,pstr(" ") ); return 0; } void CTitleLine::PDBASCIIDump ( pstr S, int N ) { if (N==0) strcpy ( S,"TITLE " ); else sprintf ( S,"TITLE %2i",N+1 ); strcat ( S,Line ); } void CTitleLine::write ( RCFile f ) { byte Version=1; f.WriteByte ( &Version ); CContString::write ( f ); } void CTitleLine::read ( RCFile f ) { byte Version; f.ReadByte ( &Version ); CContString::read ( f ); } MakeStreamFunctions(CTitleLine) // =================== CCaveat ====================== CCaveat::CCaveat() : CContString() { InitCaveat(); } CCaveat::CCaveat ( cpstr S ) : CContString() { InitCaveat(); ConvertPDBASCII ( S ); } CCaveat::CCaveat ( RPCStream Object ) : CContString(Object) { InitCaveat(); } CCaveat::~CCaveat() {} void CCaveat::InitCaveat() { strcpy ( idCode,"----" ); CreateCopy ( CIFCategory,CIFCAT_DATABASE_PDB_CAVEAT ); CreateCopy ( CIFTag ,CIFTAG_TEXT ); } int CCaveat::ConvertPDBASCII ( cpstr S ) { if (strlen(S)>12) { strncpy ( idCode,&(S[11]),4 ); idCode[4] = char(0); if (strlen(S)>19) CreateCopy ( Line,&(S[19]) ); else CreateCopy ( Line,pstr(" ") ); } else CreateCopy ( Line,pstr(" ") ); return 0; } void CCaveat::PDBASCIIDump ( pstr S, int N ) { if (N==0) strcpy ( S,"CAVEAT " ); else sprintf ( S,"CAVEAT %2i ",N+1 ); strcat ( S,idCode ); strcat ( S," " ); strcat ( S,Line ); } void CCaveat::MakeCIF ( PCMMCIFData CIF, int N ) { char S[500]; CIF->PutString ( idCode,CIFCAT_DATABASE_PDB_CAVEAT,CIFTAG_ID,False ); strcpy ( S,"\n" ); strncat ( S,Line,sizeof(S)-2 ); S[sizeof(S)-1] = char(0); CIF->PutString ( S,CIFCAT_DATABASE_PDB_CAVEAT,CIFTAG_TEXT,(N!=0) ); } void CCaveat::GetCIF ( PCMMCIFData CIF, int & Signal ) { pstr F; int RC; F = CIF->GetString ( CIFCAT_DATABASE_PDB_CAVEAT,CIFTAG_ID,RC ); if ((!RC) && F) { strncpy ( idCode,F,sizeof(IDCode) ); idCode[sizeof(IDCode)-1] = char(0); } CContString::GetCIF ( CIF,Signal ); if (Signal<0) CIF->DeleteField ( CIFCAT_DATABASE_PDB_CAVEAT,CIFTAG_ID ); } void CCaveat::Copy ( PCContainerClass Caveat ) { strcpy ( idCode,PCCaveat(Caveat)->idCode ); CContString::Copy ( Caveat ); } void CCaveat::write ( RCFile f ) { byte Version=1; f.WriteByte ( &Version ); f.WriteTerLine ( idCode,False ); CContString::write ( f ); } void CCaveat::read ( RCFile f ) { byte Version; f.ReadByte ( &Version ); f.ReadTerLine ( idCode,False ); CContString::read ( f ); } MakeStreamFunctions(CCaveat) // =================== CCompound ====================== CCompound::CCompound() : CContString() { InitCompound(); } CCompound::CCompound ( cpstr S ) : CContString() { InitCompound(); ConvertPDBASCII ( S ); } CCompound::CCompound ( RPCStream Object ) : CContString(Object) { InitCompound(); } CCompound::~CCompound() {} void CCompound::InitCompound() { CreateCopy ( CIFCategory,CIFCAT_STRUCT ); CreateCopy ( CIFTag ,CIFTAG_NDB_DESCRIPTOR ); } int CCompound::ConvertPDBASCII ( cpstr S ) { if (strlen(S)>10) CreateCopy ( Line,&(S[10]) ); else CreateCopy ( Line,pstr(" ") ); return 0; } void CCompound::PDBASCIIDump ( pstr S, int N ) { if (N==0) strcpy ( S,"COMPND " ); else sprintf ( S,"COMPND %2i",N+1 ); strcat ( S,Line ); } void CCompound::write ( RCFile f ) { byte Version=1; f.WriteByte ( &Version ); CContString::write ( f ); } void CCompound::read ( RCFile f ) { byte Version; f.ReadByte ( &Version ); CContString::read ( f ); } MakeStreamFunctions(CCompound) // =================== CSource ====================== CSource::CSource() : CContString() { InitSource(); } CSource::CSource ( cpstr S ) : CContString() { InitSource(); ConvertPDBASCII ( S ); } CSource::CSource ( RPCStream Object ) : CContString(Object) { InitSource(); } CSource::~CSource() {} void CSource::InitSource() { CreateCopy ( CIFCategory,CIFCAT_STRUCT ); CreateCopy ( CIFTag ,CIFTAG_SOURCE ); } int CSource::ConvertPDBASCII ( cpstr S ) { if (strlen(S)>10) CreateCopy ( Line,&(S[10]) ); else CreateCopy ( Line,pstr(" ") ); return 0; } void CSource::PDBASCIIDump ( pstr S, int N ) { if (N==0) strcpy ( S,"SOURCE " ); else sprintf ( S,"SOURCE %2i",N+1 ); strcat ( S,Line ); } void CSource::write ( RCFile f ) { byte Version=1; f.WriteByte ( &Version ); CContString::write ( f ); } void CSource::read ( RCFile f ) { byte Version; f.ReadByte ( &Version ); CContString::read ( f ); } MakeStreamFunctions(CSource) // =================== CKeyWords ====================== CKeyWords::CKeyWords() : CStream() { Init(); } CKeyWords::CKeyWords ( cpstr S ) : CStream() { Init(); ConvertPDBASCII ( S ); } CKeyWords::CKeyWords ( RPCStream Object ) : CStream(Object) { Init(); } CKeyWords::~CKeyWords() { Delete(); } void CKeyWords::Init() { nKeyWords = 0; KeyWord = NULL; Cont = False; } void CKeyWords::Delete() { int i; if (KeyWord) { for (i=0;i0) && (L[m]==' ')) m--; // remove padding spaces m++; L[m] = char(0); if (Cont) CreateConcat ( KeyWord[nKeyWords],L ); else CreateCopy ( KeyWord[nKeyWords],L ); if (S[i]==',') { i++; Cont = False; } else Cont = True; nKeyWords++; } return 0; } void CKeyWords::PDBASCIIDump ( RCFile f ) { int N,i,k,m1,m2,ms; char S[85]; char c; if (KeyWord) { N = 0; i = 0; while (i70) { CIF->PutString ( S,CIFCAT_STRUCT_KEYWORDS,CIFTAG_TEXT,True ); if (k>(int)sizeof(S)) { CIF->PutString ( KeyWord[i],CIFCAT_STRUCT_KEYWORDS, CIFTAG_TEXT,True ); k = 0; } strcpy ( S,"\n" ); } if (k>0) { strcat ( S,KeyWord[i] ); if (i1) CIF->PutString ( S,CIFCAT_STRUCT_KEYWORDS,CIFTAG_TEXT,True ); } void CKeyWords::GetCIF ( PCMMCIFData CIF ) { pstr F; int i,j,k; Boolean NB; char c; Delete(); F = CIF->GetString ( CIFCAT_STRUCT_KEYWORDS,CIFTAG_TEXT,i ); k = 0; if ((!i) && F) { i = 0; NB = False; while (F[i]) { if (F[i]==',') { nKeyWords++; NB = False; } else if (F[i]!=' ') NB = True; i++; } if (NB) nKeyWords++; KeyWord = new pstr[nKeyWords]; i = 0; while (F[i] && (kDeleteField ( CIFCAT_STRUCT_KEYWORDS,CIFTAG_TEXT ); } void CKeyWords::Copy ( PCKeyWords KeyWords ) { int i; Delete(); nKeyWords = KeyWords->nKeyWords; if (nKeyWords>0) { KeyWord = new pstr[nKeyWords]; for (i=0;iKeyWord[i] ); } } } void CKeyWords::write ( RCFile f ) { int i; byte Version=1; f.WriteByte ( &Version ); f.WriteInt ( &nKeyWords ); for (i=0;i0) { KeyWord = new pstr[nKeyWords]; for (i=0;i10) CreateCopy ( Line,&(S[10]) ); else CreateCopy ( Line,pstr(" ") ); return 0; } void CExpData::PDBASCIIDump ( pstr S, int N ) { if (N==0) strcpy ( S,"EXPDTA " ); else sprintf ( S,"EXPDTA %2i",N+1 ); strcat ( S,Line ); } void CExpData::write ( RCFile f ) { byte Version=1; f.WriteByte ( &Version ); CContString::write ( f ); } void CExpData::read ( RCFile f ) { byte Version; f.ReadByte ( &Version ); CContString::read ( f ); } MakeStreamFunctions(CExpData) // =================== CMdlType ====================== CMdlType::CMdlType() : CContString() { InitMdlType(); } CMdlType::CMdlType ( cpstr S ) : CContString() { InitMdlType(); ConvertPDBASCII ( S ); } CMdlType::CMdlType ( RPCStream Object ) : CContString(Object) { InitMdlType(); } CMdlType::~CMdlType() {} void CMdlType::InitMdlType() { CreateCopy ( CIFCategory,CIFCAT_EXPTL ); CreateCopy ( CIFTag ,CIFTAG_METHOD ); } int CMdlType::ConvertPDBASCII ( cpstr S ) { if (strlen(S)>10) CreateCopy ( Line,&(S[10]) ); else CreateCopy ( Line,pstr(" ") ); return 0; } void CMdlType::PDBASCIIDump ( pstr S, int N ) { if (N==0) strcpy ( S,"MDLTYP " ); else sprintf ( S,"MDLTYP %2i",N+1 ); strcat ( S,Line ); } void CMdlType::write ( RCFile f ) { byte Version=1; f.WriteByte ( &Version ); CContString::write ( f ); } void CMdlType::read ( RCFile f ) { byte Version; f.ReadByte ( &Version ); CContString::read ( f ); } MakeStreamFunctions(CMdlType) // =================== CAuthor ====================== CAuthor::CAuthor() : CContString() { InitAuthor(); } CAuthor::CAuthor ( cpstr S ) : CContString() { InitAuthor(); ConvertPDBASCII ( S ); } CAuthor::CAuthor ( RPCStream Object ) : CContString(Object) { InitAuthor(); } CAuthor::~CAuthor() {} void CAuthor::InitAuthor() { CreateCopy ( CIFCategory,CIFCAT_AUDIT_AUTHOR ); CreateCopy ( CIFTag ,CIFTAG_NAME ); } int CAuthor::ConvertPDBASCII ( cpstr S ) { if (strlen(S)>10) CreateCopy ( Line,&(S[10]) ); else CreateCopy ( Line,pstr(" ") ); return 0; } void CAuthor::PDBASCIIDump ( pstr S, int N ) { if (N==0) strcpy ( S,"AUTHOR " ); else sprintf ( S,"AUTHOR %2i",N+1 ); strcat ( S,Line ); } void CAuthor::write ( RCFile f ) { byte Version=1; f.WriteByte ( &Version ); CContString::write ( f ); } void CAuthor::read ( RCFile f ) { byte Version; f.ReadByte ( &Version ); CContString::read ( f ); } MakeStreamFunctions(CAuthor) // ================ CRevData =================== CRevData::CRevData() : CContainerClass() { InitRevData(); } CRevData::CRevData ( cpstr S ) : CContainerClass() { InitRevData(); ConvertPDBASCII ( S ); } CRevData::CRevData ( RPCStream Object ) : CContainerClass(Object) { InitRevData(); } CRevData::~CRevData() {} void CRevData::InitRevData() { int i; modNum = 0; strcpy ( modDate,"DD-MMM-YYYY" ); strcpy ( modId , "----" ); modType = -1; for (i=0;i<4;i++) strcpy ( record[i]," " ); Warning = 0; } void CRevData::PDBASCIIDump ( pstr S, int N ) { // makes the ASCII PDB REVDATA line number N // from the class' data int i; if (N==0) sprintf ( S,"REVDAT %3i " ,modNum ); else sprintf ( S,"REVDAT %3i%2i",modNum,N+1 ); i = strlen(S); while (i<80) S[i++] = ' '; S[i] = char(0); Date11to9 ( modDate,&(S[13]) ); strncpy ( &(S[23]),modId,5 ); S[31] = char(modType+int('0')); for (i=0;i<4;i++) strncpy ( &(S[39+i*7]),record[i],6 ); } void CRevData::MakeCIF ( PCMMCIFData CIF, int N ) { PCMMCIFLoop Loop; int RC,i,j; char DateCIF[20]; RC = CIF->AddLoop ( CIFCAT_DATABASE_PDB_REV,Loop ); if ((RC!=CIFRC_Ok) || (N==0)) { // the category was (re)created, privide tags Loop->AddLoopTag ( CIFTAG_NUM ); Loop->AddLoopTag ( CIFTAG_DATE ); Loop->AddLoopTag ( CIFTAG_REPLACES ); Loop->AddLoopTag ( CIFTAG_MOD_TYPE ); Loop->AddLoopTag ( CIFTAG_RCSB_RECORD_REVISED_1 ); Loop->AddLoopTag ( CIFTAG_RCSB_RECORD_REVISED_2 ); Loop->AddLoopTag ( CIFTAG_RCSB_RECORD_REVISED_3 ); Loop->AddLoopTag ( CIFTAG_RCSB_RECORD_REVISED_4 ); } Date11toCIF ( modDate,DateCIF ); Loop->AddInteger ( modNum ); Loop->AddString ( DateCIF ); Loop->AddString ( modId ); Loop->AddInteger ( modType ); for (i=0;i<4;i++) { j = 0; while (record[i][j] && (record[i][j]==' ')) j++; if (record[i][j]) Loop->AddString ( record[i] ); else Loop->AddString ( NULL ); } } void CRevData::GetCIF ( PCMMCIFData CIF, int & Signal ) { PCMMCIFLoop Loop; int RC; pstr F; Loop = CIF->GetLoop ( CIFCAT_DATABASE_PDB_REV ); if (!Loop) { Signal = -1; return; } RC = Loop->GetInteger ( modNum,CIFTAG_NUM,Signal,True ); if (RC==CIFRC_WrongIndex) { Signal = -1; return; } if (RC==CIFRC_WrongFormat) { sprintf ( CIFErrorLocation,"loop %s.%s row %i", CIFCAT_DATABASE_PDB_REV,CIFTAG_NUM,Signal ); Signal = -Error_UnrecognizedInteger-1; return; } F = Loop->GetString ( CIFTAG_DATE,Signal,RC ); if ((!RC) && F) DateCIFto11 ( F,modDate ); F = Loop->GetString ( CIFTAG_REPLACES,Signal,RC ); if ((!RC) && F) strcpy ( modId,F ); RC = Loop->GetInteger ( modType,CIFTAG_MOD_TYPE,Signal,True ); if (RC==CIFRC_WrongFormat) { sprintf ( CIFErrorLocation,"loop %s.%s row %i", CIFCAT_DATABASE_PDB_REV,CIFTAG_MOD_TYPE,Signal ); Signal = -Error_UnrecognizedInteger-1; return; } F = Loop->GetString ( CIFTAG_RCSB_RECORD_REVISED_1,Signal,RC ); if ((!RC) && F) strcpy ( record[0],F ); F = Loop->GetString ( CIFTAG_RCSB_RECORD_REVISED_2,Signal,RC ); if ((!RC) && F) strcpy ( record[1],F ); F = Loop->GetString ( CIFTAG_RCSB_RECORD_REVISED_3,Signal,RC ); if ((!RC) && F) strcpy ( record[2],F ); F = Loop->GetString ( CIFTAG_RCSB_RECORD_REVISED_4,Signal,RC ); if ((!RC) && F) strcpy ( record[3],F ); Loop->DeleteField ( CIFTAG_DATE ,Signal ); Loop->DeleteField ( CIFTAG_REPLACES ,Signal ); Loop->DeleteField ( CIFTAG_RCSB_RECORD_REVISED_1,Signal ); Loop->DeleteField ( CIFTAG_RCSB_RECORD_REVISED_2,Signal ); Loop->DeleteField ( CIFTAG_RCSB_RECORD_REVISED_3,Signal ); Loop->DeleteField ( CIFTAG_RCSB_RECORD_REVISED_4,Signal ); Signal++; } int CRevData::ConvertPDBASCII ( cpstr S ) { int i; pstr endptr; char N[20]; Warning = 0; strncpy ( N,&(S[7]),3 ); N[3] = char(0); modNum = mround(strtod(N,&endptr)); if (endptr==N) Warning |= REVDAT_WARN_MODNUM; Date9to11 ( &(S[13]),modDate ); strncpy ( modId,&(S[23]),5 ); modId[5] = char(0); modType = int(S[31]) - int('0'); if (modType>9) Warning |= REVDAT_WARN_MODTYPE; for (i=0;i<4;i++) { strncpy ( record[i],&(S[39+i*7]),6 ); record[i][6] = char(0); } return 0; } void CRevData::Copy ( PCContainerClass RevData ) { int i; modNum = PCRevData(RevData)->modNum; modType = PCRevData(RevData)->modType; strcpy ( modDate,PCRevData(RevData)->modDate ); strcpy ( modId ,PCRevData(RevData)->modId ); for (i=0;i<4;i++) strcpy ( record[i],PCRevData(RevData)->record[i] ); } void CRevData::write ( RCFile f ) { int i; byte Version=1; f.WriteByte ( &Version ); f.WriteInt ( &modNum ); f.WriteInt ( &modType ); f.WriteWord ( &Warning ); f.WriteTerLine ( modDate,False ); f.WriteTerLine ( modId ,False ); for (i=0;i<4;i++) f.WriteTerLine ( record[i],False ); } void CRevData::read ( RCFile f ) { int i; byte Version; f.ReadByte ( &Version ); f.ReadInt ( &modNum ); f.ReadInt ( &modType ); f.ReadWord ( &Warning ); f.ReadTerLine ( modDate,False ); f.ReadTerLine ( modId ,False ); for (i=0;i<4;i++) f.ReadTerLine ( record[i],False ); } MakeStreamFunctions(CRevData) // ================ CSupersede =================== CSupersede::CSupersede() : CContainerClass() { InitSupersede(); } CSupersede::CSupersede ( cpstr S ) : CContainerClass() { InitSupersede(); ConvertPDBASCII ( S ); } CSupersede::CSupersede ( RPCStream Object ) : CContainerClass(Object) { InitSupersede(); } CSupersede::~CSupersede() {} void CSupersede::InitSupersede() { int i; strcpy ( sprsdeDate,"DD-MMM-YYYY" ); strcpy ( idCode, "----" ); for (i=0;i<8;i++) strcpy ( sIdCode[i]," " ); } void CSupersede::PDBASCIIDump ( pstr S, int N ) { // makes the ASCII PDB OBSLTE line number N // from the class' data int i; if (N==0) strcpy ( S,"SPRSDE " ); else sprintf ( S,"SPRSDE %2i",N+1 ); i = strlen(S); while (i<80) S[i++] = ' '; S[i] = char(0); if (N==0) { Date11to9 ( sprsdeDate,&(S[11]) ); strncpy ( &(S[21]),idCode,4 ); } for (i=0;i<8;i++) strncpy ( &(S[31+5*i]),sIdCode[i],4 ); } void CSupersede::MakeCIF ( PCMMCIFData CIF, int ) { PCMMCIFLoop Loop; int RC,i,j; char DateCIF[20]; RC = CIF->AddLoop ( CIFCAT_SPRSDE,Loop ); if (RC!=CIFRC_Ok) { // the category was (re)created, privide tags Loop->AddLoopTag ( CIFTAG_ID ); Loop->AddLoopTag ( CIFTAG_DATE ); Loop->AddLoopTag ( CIFTAG_REPLACE_PDB_ID ); Loop->AddLoopTag ( CIFTAG_PDB_ID ); } Date11toCIF ( sprsdeDate,DateCIF ); for (i=0;i<8;i++) { j = 0; while (sIdCode[i][j] && (sIdCode[i][j]==' ')) j++; if (sIdCode[i][j]) { Loop->AddString ( pstr("SPRSDE") ); Loop->AddString ( DateCIF ); Loop->AddString ( idCode ); Loop->AddString ( sIdCode[i] ); } } } int CSupersede::ConvertPDBASCII ( cpstr S ) { int i; if (S[9]==' ') { Date9to11 ( &(S[11]),sprsdeDate ); strncpy ( idCode,&(S[21]),4 ); idCode[4] = char(0); } for (i=0;i<8;i++) { strncpy ( sIdCode[i],&(S[31+i*5]),4 ); sIdCode[i][4] = char(0); } return 0; } void CSupersede::GetCIF ( PCMMCIFData CIF, int & Signal ) { PCMMCIFLoop Loop; int i,RC; pstr F,FDate,FID; char DateCIF [20]; char DateCIF0[20]; IDCode idCode1; Loop = CIF->GetLoop ( CIFCAT_SPRSDE ); if (!Loop) { Signal = -1; // signal to finish processing of this structure return; } i = 0; do { F = Loop->GetString ( CIFTAG_ID,Signal,RC ); if (RC) { if (i==0) Signal = -1; return; } if (F) { if (!strcmp(F,"SPRSDE")) { FDate = Loop->GetString ( CIFTAG_DATE,Signal,RC ); if ((!RC) && FDate) strncpy ( DateCIF,FDate,15 ); else strcpy ( DateCIF,"YYYY-MMM-DD" ); FID = Loop->GetString ( CIFTAG_REPLACE_PDB_ID,Signal,RC ); if ((!RC) && FID) strncpy ( idCode1,FID,sizeof(IDCode)-1 ); else idCode1[0] = char(0); if (i==0) { DateCIFto11 ( DateCIF,sprsdeDate ); DateCIF[11] = char(0); strcpy ( idCode ,idCode1 ); strcpy ( DateCIF0,DateCIF ); } else if ((strcmp(DateCIF0,DateCIF)) || (strcmp(idCode,idCode1))) return; FID = Loop->GetString ( CIFTAG_PDB_ID,Signal,RC ); if ((!RC) && FID) strncpy ( sIdCode[i],FID,sizeof(IDCode)-1 ); else sIdCode[i][0] = char(0); Loop->DeleteField ( CIFTAG_ID ,Signal ); Loop->DeleteField ( CIFTAG_DATE ,Signal ); Loop->DeleteField ( CIFTAG_REPLACE_PDB_ID,Signal ); Loop->DeleteField ( CIFTAG_PDB_ID ,Signal ); i++; } } Signal++; } while (i<8); } void CSupersede::Copy ( PCContainerClass Supersede ) { int i; strcpy ( sprsdeDate,PCSupersede(Supersede)->sprsdeDate ); strcpy ( idCode ,PCSupersede(Supersede)->idCode ); for (i=0;i<8;i++) strcpy ( sIdCode[i],PCSupersede(Supersede)->sIdCode[i] ); } void CSupersede::write ( RCFile f ) { int i; byte Version=1; f.WriteByte ( &Version ); f.WriteTerLine ( sprsdeDate,False ); f.WriteTerLine ( idCode ,False ); for (i=0;i<8;i++) f.WriteTerLine ( sIdCode[i],False ); } void CSupersede::read ( RCFile f ) { int i; byte Version; f.ReadByte ( &Version ); f.ReadTerLine ( sprsdeDate,False ); f.ReadTerLine ( idCode ,False ); for (i=0;i<8;i++) f.ReadTerLine ( sIdCode[i],False ); } MakeStreamFunctions(CSupersede) // =================== CJournal ====================== CJournal::CJournal() : CContString() { InitJournal(); } CJournal::CJournal ( cpstr S ) : CContString() { InitJournal(); ConvertPDBASCII ( S ); } CJournal::CJournal ( RPCStream Object ) : CContString(Object) { InitJournal(); } CJournal::~CJournal() {} void CJournal::InitJournal() { CreateCopy ( CIFCategory,CIFCAT_CITATION ); CreateCopy ( CIFTag ,CIFTAG_TEXT ); } int CJournal::ConvertPDBASCII ( cpstr S ) { if (strlen(S)>10) CreateCopy ( Line,&(S[10]) ); else CreateCopy ( Line,pstr(" ") ); return 0; } void CJournal::PDBASCIIDump ( pstr S, int ) { strcpy ( S,"JRNL " ); strcat ( S,Line ); } void CJournal::write ( RCFile f ) { byte Version=1; f.WriteByte ( &Version ); CContString::write ( f ); } void CJournal::read ( RCFile f ) { byte Version; f.ReadByte ( &Version ); CContString::read ( f ); } MakeStreamFunctions(CJournal) // =================== CRemark ====================== CRemark::CRemark() : CContainerClass() { InitRemark(); } CRemark::CRemark ( cpstr S ) : CContainerClass() { InitRemark(); ConvertPDBASCII ( S ); } CRemark::CRemark ( RPCStream Object ) : CContainerClass(Object) { InitRemark(); } CRemark::~CRemark() { if (Remark) delete[] Remark; } void CRemark::InitRemark() { remarkNum = 0; Remark = NULL; } int CRemark::ConvertPDBASCII ( cpstr S ) { int i; GetInteger ( remarkNum,&(S[7]),3 ); if (remarkNum==MinInt4) CreateCopy ( Remark,S ); else if (strlen(S)>11) CreateCopy ( Remark,&(S[11]) ); else CreateCopy ( Remark,pstr(" ") ); i = strlen(Remark)-1; while ((i>0) && (Remark[i]==' ')) i--; Remark[i+1] = char(0); return 0; } void CRemark::PDBASCIIDump ( pstr S, int ) { if (remarkNum==MinInt4) strcpy ( S,Remark ); else { strcpy ( S,"REMARK" ); PadSpaces ( S,80 ); PutInteger ( &(S[7]) ,remarkNum,3 ); strncpy ( &(S[11]),Remark,IMin(68,strlen(Remark)) ); } } void CRemark::MakeCIF ( PCMMCIFData CIF, int N ) { PCMMCIFLoop Loop; int RC; RC = CIF->AddLoop ( CIFCAT_NDB_DATABASE_REMARK,Loop ); if ((RC!=CIFRC_Ok) || (N==0)) { // the category was (re)created, privide tags Loop->AddLoopTag ( CIFTAG_ID ); Loop->AddLoopTag ( CIFTAG_TEXT ); } if (remarkNum==MinInt4) Loop->AddString ( NULL ); else Loop->AddInteger ( remarkNum ); Loop->AddString ( Remark ); } void CRemark::GetCIF ( PCMMCIFData CIF, int & Signal ) { PCMMCIFLoop Loop; int RC; Loop = CIF->GetLoop ( CIFCAT_NDB_DATABASE_REMARK ); if (!Loop) { Signal = -1; return; } if (Signal>=Loop->GetLoopLength() ) { Signal = -1; return; } RC = Loop->GetInteger ( remarkNum,CIFTAG_ID,Signal,True ); if (RC==CIFRC_WrongFormat) { sprintf ( CIFErrorLocation,"loop %s.%s row %i", CIFCAT_NDB_DATABASE_REMARK,CIFTAG_ID,Signal ); Signal = -Error_UnrecognizedInteger-1; return; } else if (RC) remarkNum = MinInt4; Loop->GetString ( Remark,CIFTAG_TEXT,Signal,True ); Signal++; } void CRemark::Copy ( PCContainerClass RemarkClass ) { remarkNum = PCRemark(RemarkClass)->remarkNum; CreateCopy ( Remark,PCRemark(RemarkClass)->Remark ); } void CRemark::write ( RCFile f ) { byte Version=1; f.WriteByte ( &Version ); f.WriteInt ( &remarkNum ); f.CreateWrite ( Remark ); } void CRemark::read ( RCFile f ) { byte Version; f.ReadByte ( &Version ); f.ReadInt ( &remarkNum ); f.CreateRead ( Remark ); } MakeStreamFunctions(CRemark) // ================= CBiomolecule ===================== #define R350_ERRBIOMT (-3) #define R350_ERROR (-2) #define R350_END (-1) #define R350_NONE 0 #define R350_BIOMOLECULE 1 #define R350_CHAINS 2 #define R350_BIOMT 3 void getRemarkKey ( RPCRemark rem, int & lkey ) { if (rem) { if (rem->remarkNum!=350) lkey = R350_END; else if (rem->Remark) { if (strcasestr(rem->Remark,"BIOMOLECULE:")) lkey = R350_BIOMOLECULE; else if (strcasestr(rem->Remark,"CHAINS:")) lkey = R350_CHAINS; else if (strcasestr(rem->Remark,"BIOMT1") || strcasestr(rem->Remark,"BIOMT2") || strcasestr(rem->Remark,"BIOMT3")) lkey = R350_BIOMT; else lkey = R350_NONE; } } } int lookupRemarks ( int & i, RPCRemark rem, RCTitleContainer Remark ) { int l,lkey; l = Remark.Length(); lkey = R350_NONE; while ((iRemark,"CHAINS:" ); if (p) p += 7; else { p = rem->Remark; while (*p==' ') p++; if ((p[1]!=',') && (p[1]!=' ')) p = NULL; } if (p) { nAdd = strlen(p)/2 + 3; ch1 = chain; chain = new ChainID[nChains+nAdd]; for (j=0;jremarkNum!=350) lkey = R350_END; else getRemarkKey ( rem,lkey ); } } else lkey = R350_END; } while ((!rem) && (lkey==R350_NONE)); } return lkey; } int getBIOMT ( RPCRemark rem, int biomtNo, mat44 & t, RCTitleContainer Remark, int & i ) { char PN[20]; pstr p1,p2; int l,j,lkey; sprintf ( PN,"BIOMT%1i",biomtNo ); p1 = strcasestr ( rem->Remark,PN ); if (!p1) return R350_ERRBIOMT; p1 += 6; while (*p1==' ') p1++; while (*p1 && (*p1!=' ')) p1++; l = biomtNo - 1; t[l][0] = strtod ( p1,&p2 ); if (p1==p2) return R350_ERRBIOMT; t[l][1] = strtod ( p2,&p1 ); if (p1==p2) return R350_ERRBIOMT; t[l][2] = strtod ( p1,&p2 ); if (p1==p2) return R350_ERRBIOMT; t[l][3] = strtod ( p2,&p1 ); if (p1==p2) return R350_ERRBIOMT; if (biomtNo==3) { for (j=0;j<3;j++) t[3][j] = 0.0; t[3][3] = 1.0; } l = Remark.Length(); lkey = R350_BIOMT; do { i++; if (iremarkNum!=350) lkey = R350_END; else getRemarkKey ( rem,lkey ); } } else lkey = R350_END; } while ((lkey==R350_NONE) || ((!rem) && (lkey==R350_BIOMT))); return lkey; } int CBMApply::addMatrices ( int & i, RPCRemark rem, RCTitleContainer Remark ) { pmat44 tm1; int l,lkey,j,k1,k2,nAlloc; l = Remark.Length(); lkey = R350_BIOMT; nAlloc = nMatrices; while ((i=nAlloc) { nAlloc = nMatrices + 10; tm1 = tm; tm = new mat44[nAlloc]; for (j=0;jnChains; if (nChains>0) { chain = new ChainID[nChains]; for (i=0;ichain[i] ); } nMatrices = BMA->nMatrices; if (nMatrices>0) { tm = new mat44[nMatrices]; for (i=0;itm[i][j][k]; } } } void CBMApply::write ( RCFile f ) { int i,j,k; f.WriteInt ( &nChains ); for (i=0;i0) { chain = new ChainID[nChains]; for (i=0;i0) { tm = new mat44[nMatrices]; for (i=0;inChains*BMApply[i]->nMatrices; return k; } Boolean CBiomolecule::checkComposition ( PChainID chID, ivector occ, ivector wocc, int n ) { // chID[n] is list of chain IDs // occ[n] is list of chain occurencies // wocc[n] is working array int i,j,k,k1; Boolean cmp; for (i=0;inChains) && cmp;j++) { k1 = -1; for (k=0;(kchain[j])) k1 = k; if (k1<0) cmp = False; // chain not found in the list else wocc[k1] += BMApply[i]->nMatrices; } for (i=0;(inBMAs; if (nBMAs>0) { BMApply = new PCBMApply[nBMAs]; for (i=0;iBMApply[i]) { BMApply[i] = new CBMApply(); BMApply[i]->Copy ( B->BMApply[i] ); } else BMApply[i] = NULL; } } } void CBiomolecule::write ( RCFile f ) { int i; f.WriteInt ( &nBMAs ); for (i=0;i0) { BMApply = new PCBMApply[nBMAs]; for (i=0;i=10) && (PDBString[i]==' ')) i--; i++; c = PDBString[i]; PDBString[i] = char(0); CreateCopy ( classification,&(PDBString[10]) ); PDBString[i] = c; Date9to11 ( &(PDBString[50]),depDate ); strncpy ( idCode,&(PDBString[62]),4 ); idCode[4] = char(0); } else if (!strncmp(PDBString,"OBSLTE",6)) { ContainerClass = new CObsLine(PDBString); ObsData.AddData ( ContainerClass ); } else if (!strncmp(PDBString,"TITLE ",6)) { ContainerClass = new CTitleLine(PDBString); Title.AddData ( ContainerClass ); } else if (!strncmp(PDBString,"CAVEAT",6)) { ContainerClass = new CCaveat(PDBString); CAVEAT.AddData ( ContainerClass ); } else if (!strncmp(PDBString,"COMPND",6)) { ContainerClass = new CCompound(PDBString); Compound.AddData ( ContainerClass ); } else if (!strncmp(PDBString,"SOURCE",6)) { ContainerClass = new CSource(PDBString); Source.AddData ( ContainerClass ); } else if (!strncmp(PDBString,"KEYWDS",6)) { KeyWords.ConvertPDBASCII ( PDBString ); } else if (!strncmp(PDBString,"EXPDTA",6)) { ContainerClass = new CExpData(PDBString); ExpData.AddData ( ContainerClass ); } else if (!strncmp(PDBString,"MDLTYPE",6)) { ContainerClass = new CMdlType(PDBString); MdlType.AddData ( ContainerClass ); } else if (!strncmp(PDBString,"AUTHOR",6)) { ContainerClass = new CAuthor(PDBString); Author.AddData ( ContainerClass ); } else if (!strncmp(PDBString,"REVDAT",6)) { ContainerClass = new CRevData(PDBString); RevData.AddData ( ContainerClass ); } else if (!strncmp(PDBString,"SPRSDE",6)) { ContainerClass = new CSupersede(PDBString); Supersede.AddData ( ContainerClass ); } else if (!strncmp(PDBString,"JRNL ",6)) { ContainerClass = new CJournal(PDBString); Journal.AddData ( ContainerClass ); } else if (!strncmp(PDBString,"REMARK",6)) { ContainerClass = new CRemark(PDBString); Remark.AddData ( ContainerClass ); } else return Error_WrongSection; // check for ID code in columns 73-80 if (!col73) { if (('0'<=idCode[0]) && (idCode[0]<='9')) { if (!strncasecmp(idCode,&(PDBString[72]),4)) col73 = True; } } return 0; } PCTitleContainer CMMDBTitle::GetRemarks() { return &Remark; } PCTitleContainer CMMDBTitle::GetJournal() { return &Journal; } realtype CMMDBTitle::GetResolution() { // returns -1.0 if there is no resolution record in the file PCRemark rem; pstr p,eptr; int i,l; if (resolution>-1.5) return resolution; l = Remark.Length(); for (i=0;(iremarkNum==2) { if (rem->Remark) { p = strcasestr ( rem->Remark,"RESOLUTION" ); if (p) { while ((*p) && (*p!=' ')) p++; if (*p) { resolution = strtod ( p,&eptr ); if ((resolution<0.0) || (eptr==p)) resolution = -1.0; } } } } else if (rem->remarkNum>2) resolution = -1.0; } } return resolution; } PCBiomolecule CMMDBTitle::addBiomolecule() { PPCBiomolecule BM1; int i; BM1 = Biomolecule; Biomolecule = new PCBiomolecule[nBiomolecules+1]; for (i=0;iremarkNum==350) lkey = 1; else if (rem->remarkNum>350) lkey = -1; } if (!lkey) i++; } BMol = NULL; BMA = NULL; while (lkey>0) { rem = (PCRemark)Remark.GetContainerClass ( i ); lkey = lookupRemarks ( i,rem,Remark ); switch (lkey) { case R350_BIOMOLECULE : BMol = addBiomolecule(); i++; break; case R350_CHAINS : if (BMol) { BMA = BMol->addBMApply(); while (lkey==R350_CHAINS) lkey = BMA->addChains(i,rem,Remark); } else lkey = R350_ERROR; break; case R350_BIOMT : if (BMA) lkey = BMA->addMatrices(i,rem,Remark); else lkey = R350_ERROR; break; default : i++; } } if (lkey<=R350_ERROR) { FreeBiomolecules(); return lkey; } return nBiomolecules; } int CMMDBTitle::GetNofBiomolecules() { return nBiomolecules; } void CMMDBTitle::GetBiomolecules ( PPCBiomolecule & BM, int & nBMs ) { BM = Biomolecule; nBMs = nBiomolecules; } PCBiomolecule CMMDBTitle::GetBiomolecule ( int bmNo ) { // bmno=0,1,.. if ((0<=bmNo) && (bmNoGetDataName ( S,True ); if (!S) CIF->GetString ( S,CIFCAT_DATABASE,CIFTAG_ENTRY_ID,True ); if (!S) CIF->GetString ( S,CIFCAT_DATABASE,CIFTAG_CODE_NDB,True ); if (!S) CIF->GetString ( S,CIFCAT_DATABASE,CIFTAG_CODE_PDB,True ); if (S) { strncpy ( idCode,S,sizeof(IDCode)-1 ); idCode[sizeof(IDCode)-1] = char(0); delete[] S; S = NULL; CIF->DeleteField ( CIFCAT_DATABASE,CIFTAG_ENTRY_ID ); CIF->DeleteField ( CIFCAT_DATABASE,CIFTAG_CODE_NDB ); CIF->DeleteField ( CIFCAT_DATABASE,CIFTAG_CODE_PDB ); } else idCode[0] = char(0); CIF->GetString ( classification,CIFCAT_STRUCT_KEYWORDS, CIFTAG_NDB_KEYWORDS,True ); CIF->GetString ( S,CIFCAT_DATABASE,CIFTAG_DATE_ORIGINAL,True ); if (S) { DateCIFto11 ( S,depDate ); delete[] S; S = NULL; } else depDate[0] = char(0); ObsData .GetCIF ( CIF,ClassID_ObsLine ); Title .GetCIF ( CIF,ClassID_TitleLine ); CAVEAT .GetCIF ( CIF,ClassID_CAVEAT ); Compound.GetCIF ( CIF,ClassID_Compound ); Source .GetCIF ( CIF,ClassID_Source ); KeyWords.GetCIF ( CIF ); ExpData .GetCIF ( CIF,ClassID_ExpData ); MdlType .GetCIF ( CIF,ClassID_MdlType ); Author .GetCIF ( CIF,ClassID_Author ); RC = RevData.GetCIF ( CIF,ClassID_RevData ); if (!RC) { Supersede.GetCIF ( CIF,ClassID_Supersede ); Journal .GetCIF ( CIF,ClassID_Journal ); RC = Remark .GetCIF ( CIF,ClassID_Remark ); } return RC; } void CMMDBTitle::MakePDBHeaderString ( pstr PDBString ) { // makes the ASCII PDB HEADER line from the class' data int i; if (classification) { strcpy ( PDBString,"HEADER " ); strcat ( PDBString,classification ); i = strlen(PDBString); while (i<80) PDBString[i++] = ' '; PDBString[IMin(i,80)] = char(0); Date11to9 ( depDate,&(PDBString[50]) ); strncpy ( &(PDBString[62]),idCode,4 ); } else strcpy ( PDBString, "HEADER XXXXXXXXXXXXXXXXXXXXXXXXXXXX XX-XXX-XX ----" ); } pstr CMMDBTitle::GetStructureTitle ( pstr & S ) { // GetStructureTitle() returns the contents of TITLE record // unfolded into single line. If Title is missing, returns // contents of COMPND(:MOLECULE). If COMPND is missing, returns // HEADER. If Header is missing, returns PDB code. If no PDB // code is there, returns "Not available". PCTitleLine TLine; PCCompound CLine; pstr p; int i,cl,l; Boolean B; if (S) delete[] S; S = NULL; cl = Title.Length(); if (cl>0) { l = 0; for (i=0;iLine)+5; } S = new char[l]; S[0] = char(0); for (i=0;i0) strcat ( S," " ); strcat_des ( S,TLine->Line ); } } } else { cl = Compound.Length(); if (cl>0) { l = 0; p = NULL; B = True; for (i=0;(iLine,"MOLECULE:"); if (p) l += strlen_des(&(p[9]))+5; } else { p = strstr(CLine->Line,"MOLECULE:"); if (p) l += strlen_des(&(p[9]))+5; else { p = strchr(CLine->Line,':'); if (!p) { l += strlen_des(CLine->Line)+5; p = CLine->Line; } else B = False; } } } } if (l>0) { S = new char[l]; S[0] = char(0); p = NULL; B = True; for (i=0;(iLine,"MOLECULE:"); if (p) strcat_des ( S,&(p[9]) ); } else { p = strstr(CLine->Line,"MOLECULE:"); if (p) strcat_des ( S,&(p[9]) ); else { p = strchr(CLine->Line,':'); if (!p) { strcat_des ( S,CLine->Line ); p = CLine->Line; } else B = False; } } l = strlen(S)-1; if (S[l]==';') S[l] = char(0); } } } else { l = 0; for (i=0;iLine)+5; } S = new char[l]; S[0] = char(0); for (i=0;i0) strcat ( S," " ); strcat_des ( S,CLine->Line ); } } } } else if (classification) CreateCopy ( S,classification ); else if (idCode[0]) CreateCopy ( S,idCode ); else CreateCopy ( S,pstr("Not available") ); } if (!S[0]) CreateCopy ( S,pstr("Not available") ); return S; } void CMMDBTitle::PDBASCIIDump ( RCFile f ) { char PDBString[100]; if (classification) { MakePDBHeaderString ( PDBString ); f.WriteLine ( PDBString ); } ObsData .PDBASCIIDump ( f ); Title .PDBASCIIDump ( f ); CAVEAT .PDBASCIIDump ( f ); Compound .PDBASCIIDump ( f ); Source .PDBASCIIDump ( f ); KeyWords .PDBASCIIDump ( f ); ExpData .PDBASCIIDump ( f ); MdlType .PDBASCIIDump ( f ); Author .PDBASCIIDump ( f ); RevData .PDBASCIIDump ( f ); Supersede.PDBASCIIDump ( f ); Journal .PDBASCIIDump ( f ); Remark .PDBASCIIDump ( f ); } void CMMDBTitle::MakeCIF ( PCMMCIFData CIF ) { char DateCIF[20]; if (idCode[0]) { CIF->PutDataName ( idCode ); CIF->PutString ( idCode, CIFCAT_DATABASE,CIFTAG_ENTRY_ID ); CIF->PutString ( idCode, CIFCAT_DATABASE,CIFTAG_CODE_NDB ); CIF->PutString ( idCode, CIFCAT_DATABASE,CIFTAG_CODE_PDB ); } else { CIF->PutDataName ( pstr("") ); CIF->PutString ( NULL, CIFCAT_DATABASE,CIFTAG_ENTRY_ID ); CIF->PutString ( NULL, CIFCAT_DATABASE,CIFTAG_CODE_NDB ); CIF->PutString ( NULL, CIFCAT_DATABASE,CIFTAG_CODE_PDB ); } CIF->PutString ( classification, CIFCAT_STRUCT_KEYWORDS, CIFTAG_NDB_KEYWORDS ); if (depDate[0]) { Date11toCIF ( depDate,DateCIF ); CIF->PutString ( DateCIF,CIFCAT_DATABASE,CIFTAG_DATE_ORIGINAL ); } else CIF->PutString ( NULL,CIFCAT_DATABASE,CIFTAG_DATE_ORIGINAL ); ObsData .MakeCIF ( CIF ); Title .MakeCIF ( CIF ); CAVEAT .MakeCIF ( CIF ); Compound .MakeCIF ( CIF ); Source .MakeCIF ( CIF ); KeyWords .MakeCIF ( CIF ); ExpData .MakeCIF ( CIF ); MdlType .MakeCIF ( CIF ); Author .MakeCIF ( CIF ); RevData .MakeCIF ( CIF ); Supersede.MakeCIF ( CIF ); Journal .MakeCIF ( CIF ); Remark .MakeCIF ( CIF ); } void CMMDBTitle::Copy ( PCMMDBTitle TS ) { int i; FreeBiomolecules(); if (TS) { CreateCopy ( classification,TS->classification ); strcpy ( depDate ,TS->depDate ); strcpy ( idCode ,TS->idCode ); resolution = TS->resolution; ObsData .Copy ( &(TS->ObsData) ); Title .Copy ( &(TS->Title) ); CAVEAT .Copy ( &(TS->CAVEAT) ); Compound .Copy ( &(TS->Compound) ); Source .Copy ( &(TS->Source) ); KeyWords .Copy ( &(TS->KeyWords) ); ExpData .Copy ( &(TS->ExpData) ); MdlType .Copy ( &(TS->MdlType) ); Author .Copy ( &(TS->Author) ); RevData .Copy ( &(TS->RevData) ); Supersede.Copy ( &(TS->Supersede) ); Journal .Copy ( &(TS->Journal) ); Remark .Copy ( &(TS->Remark) ); nBiomolecules = TS->nBiomolecules; if (nBiomolecules>0) { Biomolecule = new PCBiomolecule[nBiomolecules]; for (i=0;iBiomolecule[i]) { Biomolecule[i] = new CBiomolecule(); Biomolecule[i]->Copy ( TS->Biomolecule[i] ); } else Biomolecule[i] = NULL; } } else { if (classification) delete[] classification; classification = NULL; resolution = -2.0; ObsData .FreeContainer(); Title .FreeContainer(); CAVEAT .FreeContainer(); Compound .FreeContainer(); Source .FreeContainer(); KeyWords .Delete (); ExpData .FreeContainer(); MdlType .FreeContainer(); Author .FreeContainer(); RevData .FreeContainer(); Supersede.FreeContainer(); Journal .FreeContainer(); Remark .FreeContainer(); } } void CMMDBTitle::TrimInput ( pstr PDBString ) { if (col73) { if (!strncasecmp(idCode,&(PDBString[72]),4)) PDBString[72] = char(0); } PadSpaces ( PDBString,80 ); } void CMMDBTitle::write ( RCFile f ) { // writes header to PDB binary file int i; byte Version=3; f.WriteByte ( &Version ); // Header data f.CreateWrite ( classification ); f.WriteTerLine ( depDate,False ); f.WriteTerLine ( idCode ,False ); f.WriteReal ( &resolution ); ObsData .write ( f ); // Obsoletion data Title .write ( f ); // Title CAVEAT .write ( f ); // Error data Compound .write ( f ); // Compound Source .write ( f ); // Source KeyWords .write ( f ); // Key words ExpData .write ( f ); // Experimental data MdlType .write ( f ); // Model descriptions Author .write ( f ); // Author data RevData .write ( f ); // Revision data Supersede.write ( f ); // Supersede records Journal .write ( f ); // Journal records Remark .write ( f ); // Remarks f.WriteInt ( &nBiomolecules ); for (i=0;i1) f.ReadReal ( &resolution ); else resolution = -2.0; ObsData .read ( f ); // Obsoletion data Title .read ( f ); // Title CAVEAT .read ( f ); // Error data Compound .read ( f ); // Compound Source .read ( f ); // Source KeyWords .read ( f ); // Key words ExpData .read ( f ); // Experimental data if (Version>2) MdlType.read ( f ); // Model descriptions Author .read ( f ); // Author data RevData .read ( f ); // Revision data Supersede.read ( f ); // Supersede records Journal .read ( f ); // Journal records Remark .read ( f ); // Remarks FreeBiomolecules(); if (Version>1) { f.ReadInt ( &nBiomolecules ); if (nBiomolecules>0) { Biomolecule = new PCBiomolecule[nBiomolecules]; for (i=0;iSetHeader ( pstr("MUSCLE PROTEIN"),pstr("02-JUN-1993"),pstr("1MYS") ); Hdr->MakePDBHeaderString ( S ); printf ( "1234567890123456789012345678901234567890" "1234567890123456789012345678901234567890\n" ); printf ( S ); printf ( "\n" ); strcpy ( S, // 1234567890123456789012345678901234567890123456789012345678901234567890 "HEADER HYDROLASE (CARBOXYLIC ESTER) 07-APR-01 2PHI" ); Hdr->ConvertPDBString ( S ); Hdr->MakePDBHeaderString ( S1 ); printf ( "1234567890123456789012345678901234567890" "1234567890123456789012345678901234567890\n" ); printf ( S1 ); printf ( "\n" ); Hdr->SetHeader ( pstr("MUSCLE PROTEIN;**A VERY LONG TITLE TEST;**ARBITRARY LENGTH"), pstr("02-JUN-1993"),pstr("1MYS") ); Hdr->MakePDBHeaderString ( S ); printf ( "1234567890123456789012345678901234567890" "1234567890123456789012345678901234567890\n" ); printf ( S ); printf ( "\n" ); delete Hdr; printf ( " header deleted \n" ); } void TestTitle() { // reads PDB title from file 'in.title' // and rewrites it into 'out.title' and 'abin.title' CFile f; char S[81]; PCMMDBTitle Title; Title = new CMMDBTitle(); f.assign ( pstr("in.title"),True ); if (f.reset()) { while (!f.FileEnd()) { f.ReadLine ( S,sizeof(S) ); Title->ConvertPDBString ( S ); } f.shut(); } else { printf ( " Can't open input file 'in.title' \n" ); delete Title; return; } f.assign ( pstr("out.title"),True ); if (f.rewrite()) { Title->PDBASCIIDump ( f ); f.shut(); } else { printf ( " Can't open output file 'out.title' \n" ); delete Title; return; } f.assign ( pstr("mmdb.title.bin"),False ); if (f.rewrite()) { Title->write ( f ); f.shut(); } else { printf ( " Can't open binary file for writing.\n" ); delete Title; return; } delete Title; printf ( " Title deleted.\n" ); Title = new CMMDBTitle(); if (f.reset()) { Title->read ( f ); f.shut(); } else { printf ( " Can't open binary file for reading.\n" ); delete Title; return; } f.assign ( pstr("abin.title"),True ); if (f.rewrite()) { Title->PDBASCIIDump ( f ); f.shut(); } else { printf ( " Can't open output file 'abin.title' \n" ); } delete Title; } */ mmdb-1.25.5/mmdb/mmdb_mmcif.cpp0000775000175000017500000026725012106546753013213 00000000000000// $Id: mmdb_mmcif.cpp,v 1.24 2012/01/26 17:52:20 ekr Exp $ // ================================================================= // // CCP4 Coordinate Library: support of coordinate-related // functionality in protein crystallography applications. // // Copyright (C) Eugene Krissinel 2000-2013. // // This library is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // // ================================================================= // // 07.02.13 <-- Date of Last Modification. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ----------------------------------------------------------------- // // **** Module : MMDB_MMCIF // ~~~~~~~~~ // **** Project : MacroMolecular Data Base (MMDB) // ~~~~~~~~~ // **** Classes : CMMCIFCategory ( mmCIF category ) // ~~~~~~~~~ CMMCIFStruct ( mmCIF structure ) // CMMCIFLoop ( mmCIF loop ) // CMMCIFData ( mmCIF data block ) // CMMCIFFile ( mmCIF file ) // // (C) E. Krissinel 2000-2013 // // ================================================================= // #ifndef __STRING_H #include #endif #ifndef __STDLIB_H #include #endif #ifndef __TIME_H #include #endif #ifndef __MMDB_MMCIF__ #include "mmdb_mmcif.h" #endif // ====================== SortTags =============================== void SortTags ( psvector tag, int len, ivector index ) { int i,k,l,l1,l2; if (len==1) { index[0] = 0; return; } if (strcasecmp(tag[0],tag[1])<0) { index[0] = 0; index[1] = 1; } else { index[0] = 1; index[1] = 0; } for (k=2;k0) l2 = k; else { l1 = 0; while (l1l2;i--) index[i] = index[i-1]; index[l2] = k; } } // ====================== CMMCIFCategory ========================== CMMCIFCategory::CMMCIFCategory() : CStream() { InitMMCIFCategory(); } CMMCIFCategory::CMMCIFCategory ( cpstr N ) : CStream() { InitMMCIFCategory(); SetCategoryName ( N ); } CMMCIFCategory::CMMCIFCategory ( RPCStream Object ) : CStream(Object) { InitMMCIFCategory(); } CMMCIFCategory::~CMMCIFCategory() { FreeMemory(); } void CMMCIFCategory::InitMMCIFCategory() { name = NULL; nTags = 0; tag = NULL; index = NULL; nAllocTags = 0; } void CMMCIFCategory::FreeMemory() { int i; if (name) delete[] name; name = NULL; for (i=0;inAllocTags) { nAT = nTagsNew + IMin(nAllocTags/2+1,20); GetVectorMemory ( tag1 ,nAT,0 ); GetVectorMemory ( index1,nAT,0 ); for (i=0;i=0) && (tagNo0) { k = 0; if (!index) GetVectorMemory ( index,nAllocTags,0 ); for (i=0;i=0 : position of the tag found // <0 : the tag was not found, it could be inserted before // (-RC-1)th element, where RC is the return value int l1,l2,l,k; if (!tag) return -1; if (!index) Sort(); l = 0; l1 = 0; l2 = nTags-1; k = 1; while (l10) l1 = l; else { l1 = l; break; } } if (k==0) return index[l]; // is at RCth position k = strcasecmp ( ttag,tag[index[l1]] ); if (k==0) return index[l1]; // is at RCth position if (k<0) return -1; // would be at (-RC-1)th position if (l2!=l1) { k = strcasecmp ( ttag,tag[index[l2]] ); if (k==0) return index[l2]; // is at RCth position if (k>0) return -2-l2; // would be at l2+1=(-RC-1)th position } return -2-l1; // would be at l1+1=(-RC-1)th position } int CMMCIFCategory::AddTag ( cpstr ttag ) { // return -1: the tag has been added on the top of array; // index is added and sorted automatically // >=0: the tag is already in the array -- its position // is returned int i1,i; if (!tag) { ExpandTags ( 3 ); // get space for first 3 tags CreateCopy ( tag[0],ttag ); nTags = 1; return -nTags; // the tag has been added on the top of array } i1 = GetTagNo ( ttag ); if (i1>=0) return i1; // non-negative returns mean that // the tag is already in the array i1 = -i1-1; // otherwise the tag has to be added and indexed at here // put new tag on the top of array and update index ExpandTags ( nTags+1 ); CreateCopy ( tag[nTags],ttag ); for (i=nTags;i>i1;i--) index[i] = index[i-1]; index[i1] = nTags; nTags++; return -nTags; // the tag has been added on the top of array } void CMMCIFCategory::PrintTags() { int i; Sort(); printf ( " Unsorted tags:\n" ); for (i=0;iname ); nTags = Category->nTags; nAllocTags = nTags; if (nTags>0) { GetVectorMemory ( tag ,nAllocTags,0 ); GetVectorMemory ( index,nAllocTags,0 ); for (i=0;itag[i] ); index[i] = Category->index[i]; } } } } void CMMCIFCategory::write ( RCFile f ) { int i; if (!index) Sort(); f.CreateWrite ( name ); f.WriteInt ( &nTags ); for (i=0;i0) { GetVectorMemory ( tag,nTags,0 ); for (i=0;inAT) { GetVectorMemory ( field1,nAllocTags,0 ); for (i=0;i=0) && (tagNo=0) && (field)) { if (field[k]) delete[] field[k]; field[k] = NULL; } return k; } int CMMCIFStruct::GetReal ( realtype & R, cpstr TName, Boolean Remove ) { pstr endptr; int RC; int k = GetTagNo ( TName ); R = 0.0; if (!field) return CIFRC_NoField; if (k<0) return CIFRC_NoTag; if (!field[k]) return CIFRC_NoField; if (field[k][0]==char(2)) return CIFRC_NoData; R = strtod ( field[k],&endptr ); if (endptr==field[k]) RC = CIFRC_WrongFormat; else { RC = 0; if (Remove) { delete[] field[k]; field[k] = NULL; } } return RC; } int CMMCIFStruct::GetInteger ( int & I, cpstr TName, Boolean Remove ) { pstr endptr; int RC; int k = GetTagNo ( TName ); I = 0; if (!field) return CIFRC_NoField; if (k<0) return CIFRC_NoTag; if (!field[k]) return CIFRC_NoField; if (field[k][0]==char(2)) { if (field[k][1]=='.') I = MinInt4; return CIFRC_NoData; } I = mround ( strtod(field[k],&endptr) ); if (endptr==field[k]) RC = CIFRC_WrongFormat; else { RC = 0; if (Remove) { delete[] field[k]; field[k] = NULL; } } return RC; } void CMMCIFStruct::PutString ( cpstr S, cpstr T, Boolean NonBlankOnly ) { pstr p; if (!S) PutNoData ( CIF_NODATA_QUESTION,T ); else { p = pstr(S); if (NonBlankOnly) while (*p==' ') p++; if (!(*p)) PutNoData ( CIF_NODATA_DOT,T ); else AddField ( S,T,False ); } } void CMMCIFStruct::PutDate ( cpstr T ) { time_t t; tm * tstruct; char S[100]; t = time ( NULL ); tstruct = localtime(&t); if (tstruct) sprintf ( S,"%4i-%02i-%02i", tstruct->tm_year+1900,tstruct->tm_mon+1,tstruct->tm_mday ); else strcpy ( S,"YYYY-MM-DD" ); AddField ( S,T,False ); } void CMMCIFStruct::PutNoData ( int NoDataType, cpstr T ) { char S[10]; S[0] = char(2); if (NoDataType==CIF_NODATA_DOT) S[1] = '.'; else S[1] = '?'; S[2] = char(0); AddField ( S,T,False ); } void CMMCIFStruct::PutReal ( realtype R, cpstr T, int prec ) { char rS[100]; sprintf ( rS,"%.*g",prec,R ); AddField ( rS,T,False ); } void CMMCIFStruct::PutReal ( realtype R, cpstr T, cpstr format ) { char rS[100]; sprintf ( rS,format,R ); AddField ( DelSpaces(rS,' '),T,False ); } void CMMCIFStruct::PutInteger ( int I, cpstr T ) { char iS[100]; if (I>MinInt4) { sprintf ( iS,"%i",I ); AddField ( iS,T,False ); } else PutNoData ( CIF_NODATA_DOT,T ); } #define NODATA_Q pstr("?") #define NODATA_P pstr(".") Boolean CMMCIFStruct::WriteMMCIFStruct ( cpstr FName, byte gzipMode ) { CFile f; f.assign ( FName,True,False,gzipMode ); if (f.rewrite()) { WriteMMCIF ( f ); f.shut(); return True; } else return False; } #define _max_output_line_width 256 void CMMCIFStruct::WriteMMCIF ( RCFile f ) { int i,j,k,l,m,n; pstr F; // calculate maximal length of tags l = 0; for (i=0;im) // wrap around if field is too long f.Write ( pstr("\n ") ); else { k = l-strlen(tag[i]); for (j=0;j0) { GetVectorMemory ( field,nTags,0 ); for (i=0;ifield[i] ); } } } void CMMCIFStruct::write ( RCFile f ) { int i; CMMCIFCategory::write ( f ); for (i=0;i0) { GetVectorMemory ( field,nTags,0 ); for (i=0;i=nTags) { delete[] field[j]; // delete empty row field[j] = NULL; } else nR++; // count non-empty row } if ((nT<=0) || (nR<=0)) FreeMemory(); // the loop is completely empty else if ((nT!=nTags) || (nR!=nAllocRows)) { f1 = new psvector[nR]; m = 0; for (j=0;jnAllocRows) { nAR = nRowsNew + IMin(nAllocRows/2+10,2000); field1 = new psvector[nAR]; for (i=0;i=nTags) iColumn = 0; } } } void CMMCIFLoop::AddNoData ( int NoDataType ) { char S[10]; S[0] = char(2); if (NoDataType==CIF_NODATA_DOT) S[1] = '.'; else S[1] = '?'; S[2] = char(0); AddString ( S ); } void CMMCIFLoop::AddReal ( realtype R, int prec ) { char rS[100]; sprintf ( rS,"%.*g",prec,R ); AddString ( rS ); } void CMMCIFLoop::AddReal ( realtype R, cpstr format ) { char rS[100]; sprintf ( rS,format,R ); AddString ( DelSpaces(rS,' ') ); } void CMMCIFLoop::AddInteger ( int I ) { char iS[100]; if (I>MinInt4) { sprintf ( iS,"%i",I ); AddString ( iS ); } else AddNoData ( CIF_NODATA_DOT ); } pstr CMMCIFLoop::GetField ( int rowNo, int tagNo ) { if ((tagNo>=0) && (tagNo=0) && (rowNo=nRows)) return CIFRC_WrongIndex; if (!field[nrow]) return CIFRC_NoField; if (!field[nrow][k]) return CIFRC_NoField; if (field[nrow][k][0]==char(2)) { if (Remove) { delete[] field[nrow][k]; field[nrow][k] = NULL; } } else if (Remove) { S = field[nrow][k]; field[nrow][k] = NULL; } else CreateCopy ( S,field[nrow][k] ); return 0; } pstr CMMCIFLoop::GetString ( cpstr TName, int nrow, int & RC ) { int k = GetTagNo ( TName ); if (k<0) { RC = CIFRC_NoTag; return NULL; } if ((nrow<0) || (nrow>=nRows)) { RC = CIFRC_WrongIndex; return NULL; } if (!field[nrow]) { RC = CIFRC_NoField; return NULL; } if (!field[nrow][k]) { RC = CIFRC_NoField; return NULL; } RC = 0; // char(2) means the field was either '.' or '?' if (field[nrow][k][0]==char(2)) return NULL; return field[nrow][k]; } // CopyString() does nothing if RC is not 0 void CMMCIFLoop::CopyString ( pstr buf, int maxlength, cpstr TName, int nrow, int & RC ) { pstr p; int k; if (RC) return; k = GetTagNo ( TName ); if (k<0) { RC = CIFRC_NoTag; buf[0] = char(0); return; } if ((nrow<0) || (nrow>=nRows)) { RC = CIFRC_WrongIndex; buf[0] = char(0); return; } if (!field[nrow]) { RC = CIFRC_NoField; buf[0] = char(0); return; } p = field[nrow][k]; if (!p) { RC = CIFRC_NoField; buf[0] = char(0); return; } // char(2) means the field was either '.' or '?' if (p[0]==char(2)) { buf[0] = p[0]; buf[1] = char(0); } else strncpy ( buf,p,IMin(maxlength,strlen(p)+1) ); } int CMMCIFLoop::DeleteField ( cpstr TName, int nrow ) { int k = GetTagNo ( TName ); if (k<0) return CIFRC_NoTag; if ((nrow<0) || (nrow>=nRows)) return CIFRC_WrongIndex; if (field[nrow]) { if (field[nrow][k]) delete[] field[nrow][k]; field[nrow][k] = NULL; } return k; } int CMMCIFLoop::DeleteRow ( int nrow ) { int i; if ((nrow<0) || (nrow>=nRows)) return CIFRC_WrongIndex; if (field[nrow]) { for (i=0;i=nRows)) return CIFRC_WrongIndex; R = 0.0; if (!field[nrow]) return CIFRC_NoField; if (!field[nrow][k]) return CIFRC_NoField; if (field[nrow][k][0]==char(2)) return CIFRC_NoField; R = strtod ( field[nrow][k],&endptr ); if (endptr==field[nrow][k]) return CIFRC_WrongFormat; if (Remove) { delete[] field[nrow][k]; field[nrow][k] = NULL; } return 0; } void CMMCIFLoop::CopyReal ( realtype & R, cpstr TName, int nrow, int & RC ) { pstr endptr; int k; if (RC) return; // R = 0.0; k = GetTagNo ( TName ); if (k<0) RC = CIFRC_NoTag; else if ((nrow<0) || (nrow>=nRows)) RC = CIFRC_WrongIndex; else if (!field[nrow]) RC = CIFRC_NoField; else if (!field[nrow][k]) RC = CIFRC_NoField; else if (field[nrow][k][0]==char(2)) RC = CIFRC_NoField; else { R = strtod ( field[nrow][k],&endptr ); if (endptr==field[nrow][k]) RC = CIFRC_WrongFormat; } } void CMMCIFLoop::CopyInteger ( int & I, cpstr TName, int nrow, int & RC ) { pstr endptr; int k; if (RC) return; I = 0; k = GetTagNo ( TName ); if (k<0) RC = CIFRC_NoTag; else if ((nrow<0) || (nrow>=nRows)) RC = CIFRC_WrongIndex; else if (!field[nrow]) RC = CIFRC_NoField; else if (!field[nrow][k]) RC = CIFRC_NoField; else if (field[nrow][k][0]==char(2)) RC = CIFRC_NoField; else { I = mround ( strtod ( field[nrow][k],&endptr ) ); if (endptr==field[nrow][k]) RC = CIFRC_WrongFormat; } } int CMMCIFLoop::GetInteger ( int & I, cpstr TName, int nrow, Boolean Remove ) { pstr endptr; int k = GetTagNo ( TName ); if (k<0) return CIFRC_NoTag; if ((nrow<0) || (nrow>=nRows)) return CIFRC_WrongIndex; I = 0; if (!field[nrow]) return CIFRC_NoField; if (!field[nrow][k]) return CIFRC_NoField; if (field[nrow][k][0]==char(2)) { if (field[nrow][k][1]=='.') I = MinInt4; return CIFRC_NoField; } I = mround ( strtod(field[nrow][k],&endptr) ); if (endptr==field[nrow][k]) return CIFRC_WrongFormat; if (Remove) { delete[] field[nrow][k]; field[nrow][k] = NULL; } return 0; } int CMMCIFLoop::GetSVector ( psvector & S, cpstr TName, int i1, int i2, Boolean Remove ) { int j,k,r1,r2; r1 = IMin(i1,i2); r2 = IMin(IMax(i1,i2),nRows-1); if ((r1<0) || (r1>=nRows) || (r2<0)) return CIFRC_WrongIndex; k = GetTagNo ( TName ); if (k<0) return CIFRC_NoTag; if (!S) GetVectorMemory ( S,r2-r1+1,r1 ); if (Remove) { for (j=r1;j<=r2;j++) if (field[j]) { S[j] = field[j][k]; field[j][k] = NULL; if (S[j]) { if (S[j][0]==char(2)) { delete[] S[j]; S[j] = NULL; } } } else S[j] = NULL; } else { for (j=r1;j<=r2;j++) { S[j] = NULL; if (field[j]) { if (field[j][k]) { if (field[j][k][0]!=char(2)) CreateCopy ( S[j],field[j][k] ); } } } } return 0; } int CMMCIFLoop::GetRVector ( rvector & R, cpstr TName, int i1, int i2, Boolean Remove ) { int j,k,r1,r2,RC; pstr endptr; r1 = IMin(i1,i2); r2 = IMin(IMax(i1,i2),nRows-1); if ((r1<0) || (r1>=nRows) || (r2<0)) return CIFRC_WrongIndex; k = GetTagNo ( TName ); if (k<0) return CIFRC_NoTag; if (!R) GetVectorMemory ( R,r2-r1+1,r1 ); RC = 0; for (j=r1;j<=r2;j++) { R[j] = 0.0; if (field[j]) { if (field[j][k]) { R[j] = strtod ( field[j][k],&endptr ); if (endptr==field[j][k]) RC = CIFRC_WrongFormat; if (Remove) { delete[] field[j][k]; field[j][k] = NULL; } } } } return RC; } int CMMCIFLoop::GetIVector ( ivector & I, cpstr TName, int i1, int i2, Boolean Remove ) { int j,k,r1,r2,RC; pstr endptr; r1 = IMin(i1,i2); r2 = IMin(IMax(i1,i2),nRows-1); if ((r1<0) || (r1>=nRows) || (r2<0)) return CIFRC_WrongIndex; k = GetTagNo ( TName ); if (k<0) return CIFRC_NoTag; if (!I) GetVectorMemory ( I,r2-r1+1,r1 ); RC = 0; for (j=r1;j<=r2;j++) { I[j] = 0; if (field[j]) { if (field[j][k]) { I[j] = mround ( strtod(field[j][k],&endptr) ); if (endptr==field[j][k]) RC = CIFRC_WrongFormat; if (Remove) { delete[] field[j][k]; field[j][k] = NULL; } } } } return RC; } void CMMCIFLoop::PutString ( cpstr S, cpstr T, int nrow ) { psmatrix field1; int nT,nR,iT,i,j; nT = nTags; nR = nRows; iT = AddTag ( T ); if (iT<0) iT = nTags-1; if (nTags>nT) { // a new tag has been added; all field must be reallocated. nRows = IMax(nR,nrow+1); // nrow is indexed like 0,1,... nAllocRows = IMax(nR,nrow+IMin(nR/2+1,2000)); field1 = new psvector[nAllocRows]; for (i=0;i=nR) { // only new rows are to be added ExpandRows ( nrow+1 ); nRows++; } if (!field[nrow]) { field[nrow] = new pstr[nTags]; for (j=0;j=nTags) iColumn = 0; } void CMMCIFLoop::PutNoData ( int NoDataType, cpstr T, int nrow ) { char S[10]; S[0] = char(2); if (NoDataType==CIF_NODATA_DOT) S[1] = '.'; else S[1] = '?'; S[2] = char(0); PutString ( S,T,nrow ); } void CMMCIFLoop::PutReal ( realtype R, cpstr T, int nrow, int prec ) { char rS[100]; sprintf ( rS,"%.*g",prec,R ); PutString ( rS,T,nrow ); } void CMMCIFLoop::PutReal ( realtype R, cpstr T, int nrow, cpstr format ) { char rS[100]; sprintf ( rS,format,R ); PutString ( DelSpaces(rS,' '),T,nrow ); } void CMMCIFLoop::PutInteger ( int I, cpstr T, int nrow ) { char iS[100]; if (I>MinInt4) { sprintf ( iS,"%i",I ); PutString ( iS,T,nrow ); } else PutNoData ( CIF_NODATA_DOT,T,nrow ); } void CMMCIFLoop::PutSVector ( psvector S, cpstr T, int i1, int i2 ) { int i,j,k; PutString ( S[i2],T,i2 ); if (iColumn==0) k = nTags-1; else k = iColumn-1; for (i=i2-1;i>=i1;i--) { if (!field[i]) { field[i] = new pstr[nTags]; for (j=0;j=i1;i--) { if (!field[i]) { field[i] = new pstr[nTags]; for (j=0;j=i1;l--) { if (!field[l]) { field[l] = new pstr[nTags]; for (j=0;j_max_output_line_width) { l[i] = -l[i]; k = 0; } } for (i=0;i_max_output_line_width) { f.LF(); m = k+1; } else while (n>0) { f.Write ( pstr(" ") ); n--; } if (field[i]) { if (field[i][j]) { F = field[i][j]; if (k>10000) { if (F[0]==char(2)) { f.Write ( pstr(" ") ); f.WriteLine ( &(F[1]) ); } else if (!F[0]) { f.Write ( pstr(" ") ); f.WriteLine ( NODATA_P ); } else { f.Write ( pstr(";") ); f.WriteLine ( F ); f.WriteLine ( pstr(";") ); } m = 0; k = 0; } else if ((((F[0]=='.') || (F[0]=='?')) && (!F[1])) || strchr(F,' ')) { f.Write ( pstr(" \"") ); f.Write ( F ); f.Write ( pstr("\"") ); k -= strlen(F)+2; } else if (F[0]==char(2)) { f.Write ( pstr(" ") ); f.Write ( &(F[1]) ); k--; } else if (!F[0]) { f.Write ( pstr(" ") ); f.Write ( NODATA_P ); k--; } else { f.Write ( pstr(" ") ); f.Write ( F ); k -= strlen(F); } } else { f.Write ( pstr(" ") ); f.Write ( NODATA_Q ); k--; } } else { f.Write ( pstr(" ") ); f.Write ( NODATA_Q ); k--; } } if (m) f.LF(); } } void CMMCIFLoop::Copy ( PCMMCIFCategory Loop ) { int i,j; CMMCIFCategory::Copy ( Loop ); nRows = PCMMCIFLoop(Loop)->nRows; nAllocRows = nRows; if ((nTags>0) && (nRows>0)) { field = new psvector[nRows]; for (i=0;ifield[i]) { field[i] = new pstr[nTags]; for (j=0;jfield[i][j] ); } } else field[i] = NULL; } } iColumn = PCMMCIFLoop(Loop)->iColumn; } void CMMCIFLoop::write ( RCFile f ) { int i,j; CMMCIFCategory::write ( f ); f.WriteInt ( &nRows ); if ((nTags>0) && (nRows>0)) for (i=0;i0) && (nRows>0)) { field = new psvector[nRows]; for (i=0;i0) { WrongCat = new pstr[nWrongFields]; WrongTag = new pstr[nWrongFields]; for (i=0;i>\n",lcount ); return CIFRC_NoDataLine; } llen = _max_buf_len; L = new char[llen]; i = 0; p += 5; while ((*p) && (*p!=' ') && (*p!=char(9))) { L[i++] = *p; p++; } L[i] = char(0); CreateCopy ( name,L ); // 2. Loop over tags until next 'data_' or end of file while (p) { // skip spaces while ((*p==' ') || (*p==char(9))) p++; if ((*p) && (*p!='#')) { // this is not a comment, continue if (*p=='_') GetDataItem ( f,S,L,p,lcount,llen ); else if (!strncmp(p,"loop_",5)) GetLoop ( f,S,L,p,lcount,llen ); else if (!strncmp(p,"data_",5)) { p = NULL; break; } else { // if got to here, the file is corrupted strcpy ( _err_string,S ); _err_line = lcount; Warning |= CIFW_UnrecognizedItems; if (flags & CIFFL_PrintWarnings) printf ( "\n **** mmCIF READ WARNING " "<>\n%s\n", lcount,S ); while ((*p) && (*p!=' ') && (*p!=char(9))) if (*p=='#') *p = char(0); else p++; } } else *p = char(0); if (Warning && (flags & CIFFL_StopOnWarnings)) { if (L) delete[] L; return Warning; } if (!(*p)) { if (!f.FileEnd()) { f.ReadLine ( S,_max_buf_len ); lcount++; p = &(S[0]); } else p = NULL; } } if (L) delete[] L; Optimize(); // get rid of over-allocated fields. return Warning; } void CMMCIFData::GetDataItem ( RCFile f, pstr S, pstr & L, pstr & p, int & lcount, int & llen ) { PCMMCIFStruct Struct; char T[100]; int RC,i; i = 0; while ((*p) && (*p!=' ') && (*p!=char(9)) && (*p!='.')) { if (i<(int)sizeof(T)-1) T[i++] = *p; p++; } T[i] = char(0); if (*p!='.') { // category name missing strcpy ( L,T ); // item name T[0] = char(1); // special T[1] = char(0); // category name } // look for category i = AddCategory ( T ); if (i<0) { // negative value means that the category was not in the list, // but a place for it has been provided and index updated Struct = new CMMCIFStruct ( T ); Category[nCategories-1] = Struct; } else { Struct = PCMMCIFStruct(Category[i]); if (Struct->GetCategoryID()!=MMCIF_Struct) { strcpy ( _err_string,S ); _err_line = lcount; Warning |= CIFW_NotAStructure; if (flags & CIFFL_PrintWarnings) printf ( "\n **** mmCIF READ WARNING " "<>\n%s\n", lcount,T,S ); delete Category[i]; Struct = new CMMCIFStruct ( T ); Category[i] = Struct; } } if (*p=='.') { // get item name i = 0; p++; // skip period while ((*p) && (*p!=' ') && (*p!=char(9))) { T[i++] = *p; p++; } T[i] = char(0); } else strcpy ( T,L ); if (nWrongFields>0) { if (CheckWrongField(Struct->name,T)) { GetField ( f,S,L,p,lcount,llen ); Struct->DeleteField ( T ); return; } } RC = GetField ( f,S,L,p,lcount,llen ); if (RC) { strcpy ( _err_string,S ); _err_line = lcount; Warning |= CIFW_MissingField; if (flags & CIFFL_PrintWarnings) printf ( "\n **** mmCIF READ WARNING " "<>\n%s\n", lcount,S ); } while ((*p==' ') || (*p==char(9))) p++; if (*p=='#') *p = char(0); i = Struct->GetTagNo ( T ); if (i>=0) { if (flags & CIFFL_SuggestTags) { tagNo++; ParamStr ( T,pstr("\1"),tagNo ); } else { strcpy ( _err_string,S ); _err_line = lcount; Warning |= CIFW_DuplicateTag; if (flags & CIFFL_PrintWarnings) printf ( "\n **** mmCIF READ WARNING " "<>\n%s\n",lcount,S ); } } Struct->AddField ( L,T ); } void CMMCIFData::GetLoop ( RCFile f, pstr S, pstr & L, pstr & p, int & lcount, int & llen ) { PCMMCIFLoop Loop; pstr p1; char T[100]; Boolean Repeat,WrongField; int RC,i,nC; RC = 0; p += 5; // skip 'loop_' tag loopNo++; Loop = NULL; nC = -1; // undefined category number do { while ((*p==' ') || (*p==char(9))) p++; p1 = p; if (*p=='_') { // get category name i = 0; while ((*p) && (*p!=' ') && (*p!=char(9)) && (*p!='.')) { if (i<(int)sizeof(T)-1) T[i++] = *p; p++; } T[i] = char(0); if (*p!='.') { // category name missing strcpy ( L,T ); // item name if (flags & CIFFL_SuggestCategories) sprintf ( T,"X%i",loopNo ); else strcpy ( T,"X" ); T[0] = char(1); // special category name } if (Loop) { if (strcmp(Loop->GetCategoryName(),T)) { // loop ended, empty p = p1; // play back to last category Loop = NULL; } } else { // look for category i = AddCategory ( T ); if ((i!=nC) && (nC>=0)) { // empty loop; most probably // a corrupted file p = p1; // play back to last category strcpy ( _err_string,S ); _err_line = lcount; Warning |= CIFW_EmptyLoop; if (flags & CIFFL_PrintWarnings) printf ( "\n **** mmCIF READ WARNING " "<>\n%s\n",lcount,S ); // AddCategory(..) has added a NULL-Category on the top of // category list; remove it now DeleteCategory ( nCategories-1 ); Loop = NULL; // return; } if (i<0) { // negative value means that the category was not in the list, // but a place for it has been provided and index updated Loop = new CMMCIFLoop ( T ); Category[nCategories-1] = Loop; nC = nCategories-1; } } /* else if (Loop) { if (!strcmp(Loop->GetCategoryName(), Category[i]->GetCategoryName())) { if (Loop->GetCategoryID()!=MMCIF_Loop) { Warning |= CIFW_NotALoop; if (flags & CIFFL_PrintWarnings) printf ( "\n **** mmCIF READ WARNING " "<>\n%s\n",lcount,T,S ); delete Category[i]; Loop = new CMMCIFLoop ( T ); Category[i] = Loop; } } else Loop = NULL; } */ if (Loop) { if (*p=='.') { // get item name i = 0; p++; // skip period while ((*p) && (*p!=' ') && (*p!=char(9))) { T[i++] = *p; p++; } T[i] = char(0); } else strcpy ( T,L ); if (nWrongFields>0) WrongField = CheckWrongField ( Loop->name,T ); else WrongField = False; if (!WrongField) { if (Loop->AddTag(T)>=0) { if (flags & CIFFL_SuggestTags) { tagNo++; ParamStr ( T,pstr("\1"),tagNo ); Loop->AddTag(T); } else { strcpy ( _err_string,S ); _err_line = lcount; Warning |= CIFW_DuplicateTag; if (flags & CIFFL_PrintWarnings) printf ( "\n **** mmCIF READ WARNING " "<>\n%s\n",lcount,S ); } } } Repeat = True; } else { p = p1; Repeat = False; } } else if (!(*p) || (*p=='#')) { Repeat = !f.FileEnd(); if (Repeat) { f.ReadLine ( S,_max_buf_len ); lcount++; p = &(S[0]); } else { strcpy ( _err_string,S ); _err_line = lcount; Warning |= CIFW_UnexpectedEOF; if (flags & CIFFL_PrintWarnings) printf ( "\n **** mmCIF READ WARNING " "<>\n%s\n", lcount,S ); } } else Repeat = False; } while (Repeat); if (Loop) { do { while ((*p==' ') || (*p==char(9))) p++; if (!(*p) || (*p=='#')) { Repeat = !f.FileEnd(); if (Repeat) { f.ReadLine ( S,_max_buf_len ); lcount++; p = &(S[0]); } } else if (*p=='_') Repeat = False; else if (!strncmp(p,"loop_",5)) Repeat = False; else if (!strncmp(p,"data_",5)) Repeat = False; else if (!strncmp(p,"stop_",5)) { p += 5; Repeat = False; } else { RC = GetField ( f,S,L,p,lcount,llen ); if (!RC) { Loop->AddString ( L ); Repeat = True; } else Repeat = False; } } while (Repeat); if ((Loop->iColumn!=0) || (RC)) { strcpy ( _err_string,S ); _err_line = lcount; Warning |= CIFW_LoopFieldMissing; if (flags & CIFFL_PrintWarnings) printf ( "\n **** mmCIF READ WARNING " "<>\n%s\n", lcount,S ); } } } int CMMCIFData::GetField ( RCFile f, pstr S, pstr & L, pstr & p, int & lcount, int & llen ) { Boolean Repeat; pstr L1; int i,flen; char c; flen = 0; L[flen] = char(0); do { // skip all spaces before the field while ((*p==' ') || (*p==char(9))) p++; if ((*p=='#') || (!(*p))) { // comment or end of line met; the field should be // found on the next line Repeat = !f.FileEnd(); if (Repeat) { // take the next line f.ReadLine ( S,_max_buf_len ); lcount++; p = &(S[0]); Repeat = (*p!=';'); } else { // end of file and the field is not taken L[0] = char(0); return 1; } } else // first symbol of a field is found Repeat = False; } while (Repeat); if (*p==';') { // this is a multiline field p++; strcpy ( L,p ); // take first line of the field flen = strlen(L); while (!f.FileEnd()) { f.ReadLine ( S,_max_buf_len ); lcount++; p = &(S[0]); if (*p==';') { // multiline field terminated p++; while ((*p==' ') || (*p==char(9))) p++; return 0; } else { // multiline field continues -- take next line flen += strlen(S)+2; if (flen>=llen) { llen = flen + IMin(2000,llen); L1 = new char[llen]; strcpy ( L1,L ); delete[] L; L = L1; } strcat ( L,"\n" ); strcat ( L,S ); } } // end of file -- take the last line of the multiline field p = &(S[strlen(S)]); } else { i = 0; if (*p!='_') { if ((*p=='\'') || (*p=='"')) { c = *p; // field in quotation marks do { p++; // stop taking characters either on end of line // or the quotation mark while ((*p) && (*p!=c)) { L[i++] = *p; p++; } while (*p==c) { // it was a quotation mark -- check that it is followed // by end of line or space p++; if ((*p) && (*p!=' ') && (*p!=char(9))) { // the quotation mark is not a field terminator and // belongs to the field. L[i++] = c; // take the quotation mark if (*p!=c) // take the non-space character L[i++] = *p; // but check for field terminator } } // terminate the loop only on space or end of line } while ((*p) && (*p!=' ') && (*p!=char(9))); if (*p) p++; L[i] = char(0); } else { // a simplest field without spaces while ((*p) && (*p!=' ') && (*p!=char(9))) { L[i++] = *p; p++; } L[i] = char(0); if (((L[0]=='.') || (L[0]=='?')) && (!L[1])) { // "no data" tokens L[1] = L[0]; L[0] = char(2); L[2] = char(0); } } } } return 0; } void CMMCIFData::Sort() { int i,k; psvector cnames; k = 0; for (i=0;iSort(); cnames[i] = NULL; CreateCopy ( cnames[i],Category[i]->name ); } SortTags ( cnames,nCategories,index ); for (i=0;i=0 : position of the category found // <0 : the category was not found, it could be inserted before // (-RC-1)th element, where RC is the return value int l1,l2,l,k; if (!Category) return -1; if (!index) Sort(); if (cname[0]) { l = 0; l1 = 0; l2 = nCategories-1; k = 1; while (l1name ); if (k<0) l2 = l; else if (k>0) l1 = l; else { l1 = l; break; } } if (k==0) return index[l]; // is at RCth position k = strcasecmp(cname,Category[index[l1]]->name); if (k==0) return index[l1]; // is at RCth position if (k<0) return -1; // would be at (-RC-1)th position if (l2!=l1) { k = strcasecmp(cname,Category[index[l2]]->name); if (k==0) return index[l2]; // is at RCth position if (k>0) return -2-l2; // would be at l2+1=(-RC-1)th position } return -2-l1; // would be at l1+1=(-RC-1)th position } else // 'root' category should be always on top if (Category[index[0]]->name[0]==char(1)) return index[0]; return -1; } int CMMCIFData::AddCategory ( cpstr cname ) { // return -1: a place for category has been added on the top of array; // index is added and sorted automatically // >=0: the category is already in the array -- its position // is returned int l1,l; PPCMMCIFCategory Category1; ivector index1; if (!Category) { Category = new PCMMCIFCategory[1]; Category[0] = NULL; GetVectorMemory ( index,1,0 ); index[0] = 0; nCategories = 1; return -nCategories; // the category has been added on the top of array } l1 = GetCategoryNo ( cname ); if (l1>=0) return l1; // non-negative returns mean that // the category is already in the array l1 = -l1-1; // otherwise the category has to be added and indexed at here // put new NULL-category on the top of array and update the index Category1 = new PCMMCIFCategory[nCategories+1]; GetVectorMemory ( index1,nCategories+1,0 ); for (l=0;lWriteMMCIF ( f ); } // --------------- Retrieving data int CMMCIFData::DeleteCategory ( cpstr CName ) { int k; k = GetCategoryNo ( CName ); if (k<0) return CIFRC_NoCategory; return DeleteCategory ( k ); } int CMMCIFData::DeleteCategory ( int CatNo ) { int i; if (Category[CatNo]) delete Category[CatNo]; for (i=CatNo+1;iCatNo) index[i]--; i++; } i++; while (iCatNo) index[i]--; index[i-1] = index[i]; i++; } nCategories--; index [nCategories] = 0; Category[nCategories] = NULL; return 0; } int CMMCIFData::DeleteStructure ( cpstr CName ) { int k; k = GetCategoryNo ( CName ); if (k<0) return CIFRC_NoCategory; if (Category[k]->GetCategoryID()==MMCIF_Struct) return DeleteCategory ( k ); else return CIFRC_NotAStructure; } int CMMCIFData::DeleteLoop ( cpstr CName ) { int k; k = GetCategoryNo ( CName ); if (k<0) return CIFRC_NoCategory; if (Category[k]->GetCategoryID()==MMCIF_Loop) return DeleteCategory ( k ); else return CIFRC_NotALoop; } PCMMCIFCategory CMMCIFData::GetCategory ( int categoryNo ) { if ((categoryNo>=0) && (categoryNoGetCategoryID()==MMCIF_Struct) return PCMMCIFStruct(Category[i]); else return NULL; } PCMMCIFLoop CMMCIFData::GetLoop ( cpstr CName ) { int i; i = GetCategoryNo ( CName ); if (i<0) return NULL; if (Category[i]->GetCategoryID()==MMCIF_Loop) return PCMMCIFLoop(Category[i]); else return NULL; } PCMMCIFLoop CMMCIFData::FindLoop ( cpstr * tagList ) { int i; for (i=0;iGetCategoryID()==MMCIF_Loop) { if (Category[i]->CheckTags(tagList)) return PCMMCIFLoop(Category[i]); } } return NULL; } void CMMCIFData::GetDataName ( pstr & dname, Boolean Remove ) { if (Remove) { if (dname) delete[] dname; dname = name; name = NULL; } else CreateCopy ( dname,name ); } int CMMCIFData::CheckData ( cpstr CName, cpstr TName ) { // CheckData(..) returns positive value if the field is in the // file: // CIFRC_Structure category CName is a structure // CIFRC_Loop category CName is a loop // Negative returns mean: // CIFRC_StructureNoTag category CName is present, // it is a structure, but it does not // have tag TName // CIFRC_LoopNoTag category CName is present, // it is a loop, but it does not have // tag TName // CIFRC_NoCategory category CName is not present. // If TName is set to NULL then only the CName is checked and // possible returns are CIFRC_Structure, CIFRC_Loop and // CIFRC_NoCategory. int i,k; i = GetCategoryNo ( CName ); if (i<0) return CIFRC_NoCategory; if (Category[i]->GetCategoryID()==MMCIF_Struct) k = CIFRC_Structure; else k = CIFRC_Loop; if (TName) { if (Category[i]->GetTagNo(TName)<0) { if (k==CIFRC_Structure) k = CIFRC_StructureNoTag; else k = CIFRC_LoopNoTag; } } return k; } void CMMCIFData::Optimize() { int i,k; PPCMMCIFCategory C1; k = 0; for (i=0;iOptimize(); if (Category[i]->nTags<=0) { delete Category[i]; Category[i] = NULL; } else k++; } if (k>0) { if (k!=nCategories) { C1 = new PCMMCIFCategory[k]; k = 0; for (i=0;iGetCategoryID()!=MMCIF_Struct) return CIFRC_NotAStructure; return PCMMCIFStruct(Category[i])->GetString ( Dest,TName,Remove ); } pstr CMMCIFData::GetString ( cpstr CName, cpstr TName, int & RC ) { int i = GetCategoryNo ( CName ); if (i<0) { RC = CIFRC_NoCategory; return NULL; } if (Category[i]->GetCategoryID()!=MMCIF_Struct) { RC = CIFRC_NotAStructure; return NULL; } return PCMMCIFStruct(Category[i])->GetString ( TName,RC ); } int CMMCIFData::DeleteField ( cpstr CName, cpstr TName ) { int i = GetCategoryNo ( CName ); if (i<0) return CIFRC_NoCategory; if (Category[i]->GetCategoryID()!=MMCIF_Struct) return CIFRC_NotAStructure; return PCMMCIFStruct(Category[i])->DeleteField ( TName ); } int CMMCIFData::GetReal ( realtype & R, cpstr CName, cpstr TName, Boolean Remove ) { int i = GetCategoryNo ( CName ); if (i<0) return CIFRC_NoCategory; if (Category[i]->GetCategoryID()!=MMCIF_Struct) return CIFRC_NotAStructure; return PCMMCIFStruct(Category[i])->GetReal ( R,TName,Remove ); } int CMMCIFData::GetInteger ( int & I, cpstr CName, cpstr TName, Boolean Remove ) { int j = GetCategoryNo ( CName ); if (j<0) return CIFRC_NoCategory; if (Category[j]->GetCategoryID()!=MMCIF_Struct) return CIFRC_NotAStructure; return PCMMCIFStruct(Category[j])->GetInteger ( I,TName,Remove ); } int CMMCIFData::GetLoopLength ( cpstr CName ) { // GetLoopLength(..) returns CIFRC_NotALoop if the category CName // is not a loop, CIFRC_NoCategory if the category CName is not // found. Non-negative returns give the length of the loop (may be // 0 if the loop is empty). int i; i = GetCategoryNo ( CName ); if (i<0) return CIFRC_NoCategory; if (Category[i]->GetCategoryID()!=MMCIF_Loop) return CIFRC_NotALoop; return PCMMCIFLoop(Category[i])->nRows; } int CMMCIFData::GetLoopString ( pstr & Dest, cpstr CName, cpstr TName, int nrow, Boolean Remove ) { // GetLoopString(..), GetLoopReal(..) and GetLoopInteger(..) act // like GetString(..), GetReal(..) and GetInteger(..) above for // nrow-th element of the 'loop_' (indexed like 0..N-1 where N // is obtained through GetLoopLength(..)). They will return // CIFRC_WrongIndex if nrow is out of range. int i = GetCategoryNo ( CName ); if (i<0) return CIFRC_NoCategory; if (Category[i]->GetCategoryID()!=MMCIF_Loop) return CIFRC_NotALoop; return PCMMCIFLoop(Category[i])->GetString ( Dest,TName,nrow,Remove ); } pstr CMMCIFData::GetLoopString ( cpstr CName, cpstr TName, int nrow, int & RC ) { int i = GetCategoryNo ( CName ); if (i<0) { RC = CIFRC_NoCategory; return NULL; } if (Category[i]->GetCategoryID()!=MMCIF_Loop) { RC = CIFRC_NotALoop; return NULL; } return PCMMCIFLoop(Category[i])->GetString ( TName,nrow,RC ); } int CMMCIFData::DeleteLoopField ( cpstr CName, cpstr TName, int nrow ) { int i = GetCategoryNo ( CName ); if (i<0) return CIFRC_NoCategory; if (Category[i]->GetCategoryID()!=MMCIF_Loop) return CIFRC_NotALoop; return PCMMCIFLoop(Category[i])->DeleteField ( TName,nrow ); } int CMMCIFData::GetLoopReal ( realtype & R, cpstr CName, cpstr TName, int nrow, Boolean Remove ) { int i = GetCategoryNo ( CName ); if (i<0) return CIFRC_NoCategory; if (Category[i]->GetCategoryID()!=MMCIF_Loop) return CIFRC_NotALoop; return PCMMCIFLoop(Category[i])->GetReal ( R,TName,nrow,Remove ); } int CMMCIFData::GetLoopInteger ( int & I, cpstr CName, cpstr TName, int nrow, Boolean Remove ) { int j = GetCategoryNo ( CName ); if (j<0) return CIFRC_NoCategory; if (Category[j]->GetCategoryID()!=MMCIF_Loop) return CIFRC_NotALoop; return PCMMCIFLoop(Category[j])->GetInteger ( I,TName,nrow,Remove ); } int CMMCIFData::GetLoopSVector ( psvector & S, cpstr CName, cpstr TName, int i1, int i2, Boolean Remove ) { // GetLoopSVector(..), GetLoopRVector(..) and GetLoopIVector(..) // read CIF 'loop_' data into allocated vectors of strings, reals and // integers, correspondingly. The vectors may be deallocated prior // to call and assigned NULL, in which case they will be allocated // with offsets of i1, which is also the lower index of the 'loop_' // data transferred into it. The upper vector index is given by i2 or // by the loop's length whichever is less. If vectors are not assigned // NULL prior the call, it is assumed that they are properly (i1-offset, // i2-i1+1 length) allocated. // The return codes are same as those of GetLoopString(..), // GetLoopReal(..) and GetLoopInteger(..). int i; i = GetCategoryNo ( CName ); if (i<0) return CIFRC_NoCategory; if (Category[i]->GetCategoryID()!=MMCIF_Loop) return CIFRC_NotALoop; return PCMMCIFLoop(Category[i])->GetSVector ( S,TName,i1,i2,Remove ); } int CMMCIFData::GetLoopRVector ( rvector & R, cpstr CName, cpstr TName, int i1, int i2, Boolean Remove ) { int i; i = GetCategoryNo ( CName ); if (i<0) return CIFRC_NoCategory; if (Category[i]->GetCategoryID()!=MMCIF_Loop) return CIFRC_NotALoop; return PCMMCIFLoop(Category[i])->GetRVector ( R,TName,i1,i2,Remove ); } int CMMCIFData::GetLoopIVector ( ivector & I, cpstr CName, cpstr TName, int i1, int i2, Boolean Remove ) { int j; j = GetCategoryNo ( CName ); if (j<0) return CIFRC_NoCategory; if (Category[j]->GetCategoryID()!=MMCIF_Loop) return CIFRC_NotALoop; return PCMMCIFLoop(Category[j])->GetIVector ( I,TName,i1,i2,Remove ); } // --------------- Storing data void CMMCIFData::PutDataName ( cpstr dname ) { // stores name for 'data_' record CreateCopy ( name,dname ); } int CMMCIFData::PutNoData ( int NoDataType, cpstr CName, cpstr TName ) { PCMMCIFStruct Struct; int i,RC; RC = CIFRC_Ok; // look for category i = AddCategory ( CName ); if (i<0) { // negative value means that the category was not in the list, // but a place for it has been provided and index updated Struct = new CMMCIFStruct ( CName ); Category[nCategories-1] = Struct; } else { Struct = PCMMCIFStruct(Category[i]); if (Struct->GetCategoryID()!=MMCIF_Struct) { RC = CIFRC_NotAStructure; delete Category[i]; Struct = new CMMCIFStruct ( CName ); Category[i] = Struct; } } Struct->PutNoData ( NoDataType,TName ); return RC; } int CMMCIFData::PutString ( cpstr S, cpstr CName, cpstr TName, Boolean Concatenate ) { // PutString(..), PutReal(..) and PutInteger(..) will put the // values given into the specified category (CName) under the // specified tag (TName). The category, tag and field are created // automatically; the field will be replaced silently if identical // CName.TName is specified in two calls. Calls of these functions // may follow in random order; however CIF file will have all tags // grouped by categories and catgories will follow in the order // of first appearance in PutString(..), PutReal(..) or // PutInteger(..). // Return code - one of CIFRC_Ok or CIFRC_NotAStruct PCMMCIFStruct Struct; int i,RC; RC = CIFRC_Ok; // look for category i = AddCategory ( CName ); if (i<0) { // negative value means that the category was not in the list, // but a place for it has been provided and index updated Struct = new CMMCIFStruct ( CName ); Category[nCategories-1] = Struct; } else { Struct = PCMMCIFStruct(Category[i]); if (Struct->GetCategoryID()!=MMCIF_Struct) { RC = CIFRC_NotAStructure; delete Category[i]; Struct = new CMMCIFStruct ( CName ); Category[i] = Struct; } } Struct->AddField ( S,TName,Concatenate ); return RC; } int CMMCIFData::PutDate ( cpstr CName, cpstr TName ) { PCMMCIFStruct Struct; int i,RC; RC = CIFRC_Ok; // look for category i = AddCategory ( CName ); if (i<0) { // negative value means that the category was not in the list, // but a place for it has been provided and index updated Struct = new CMMCIFStruct ( CName ); Category[nCategories-1] = Struct; } else { Struct = PCMMCIFStruct(Category[i]); if (Struct->GetCategoryID()!=MMCIF_Struct) { RC = CIFRC_NotAStructure; delete Category[i]; Struct = new CMMCIFStruct ( CName ); Category[i] = Struct; } } Struct->PutDate ( TName ); return RC; } int CMMCIFData::PutReal ( realtype R, cpstr CName, cpstr TName, int prec ) { char rS[100]; sprintf ( rS,"%.*g",prec,R ); return PutString ( rS,CName,TName,False ); } int CMMCIFData::PutInteger ( int I, cpstr CName, cpstr TName ) { char iS[100]; if (I>MinInt4) sprintf ( iS,"%i",I ); else { iS[0] = char(2); iS[1] = '.'; iS[2] = char(0); } return PutString ( iS,CName,TName,False ); } int CMMCIFData::AddLoop ( cpstr CName, PCMMCIFLoop & Loop ) { int i,RC; RC = CIFRC_Ok; // look for category i = AddCategory ( CName ); if (i<0) { // negative value means that the category was not in the list, // but a place for it has been provided and index updated Loop = new CMMCIFLoop ( CName ); Category[nCategories-1] = Loop; RC = CIFRC_Created; } else { Loop = PCMMCIFLoop(Category[i]); if (Loop->GetCategoryID()!=MMCIF_Loop) { RC = CIFRC_NotALoop; delete Category[i]; Loop = new CMMCIFLoop ( CName ); Category[i] = Loop; } } return RC; } int CMMCIFData::AddStructure ( cpstr CName, PCMMCIFStruct & Struct ) { int i,RC; RC = CIFRC_Ok; // look for category i = AddCategory ( CName ); if (i<0) { // negative value means that the category was not in the list, // but a place for it has been provided and index updated Struct = new CMMCIFStruct ( CName ); Category[nCategories-1] = Struct; RC = CIFRC_Created; } else { Struct = PCMMCIFStruct(Category[i]); if (Struct->GetCategoryID()!=MMCIF_Struct) { RC = CIFRC_NotAStructure; delete Category[i]; Struct = new CMMCIFStruct ( CName ); Category[i] = Struct; } } return RC; } int CMMCIFData::PutLoopNoData ( int NoDataType, cpstr CName, cpstr TName, int nrow ) { PCMMCIFLoop Loop; int i,RC; RC = CIFRC_Ok; // look for category i = AddCategory ( CName ); if (i<0) { // negative value means that the category was not in the list, // but a place for it has been provided and index updated Loop = new CMMCIFLoop ( CName ); Category[nCategories-1] = Loop; } else { Loop = PCMMCIFLoop(Category[i]); if (Loop->GetCategoryID()!=MMCIF_Loop) { RC = CIFRC_NotALoop; delete Category[i]; Loop = new CMMCIFLoop ( CName ); Category[i] = Loop; } } Loop->PutNoData ( NoDataType,TName,nrow ); return RC; } int CMMCIFData::PutLoopString ( cpstr S, cpstr CName, cpstr TName, int nrow ) { // PutLoopString(..), PutLoopReal(..) and PutLoopInteger(..) act // like PutString(..), PutReal(..) and PutInteger(..) above for // nrow-th element of the 'loop_' CName (indexed begining from 0). // In consequitive calls, given values of nrow does not have to be // ordered; the most efficient way is to start with HIGHEST value // for nrow in the loop and move down to 0. The least efficient way // is to start with nrow=0 and move up. PCMMCIFLoop Loop; int i,RC; RC = CIFRC_Ok; // look for category i = AddCategory ( CName ); if (i<0) { // negative value means that the category was not in the list, // but a place for it has been provided and index updated Loop = new CMMCIFLoop ( CName ); Category[nCategories-1] = Loop; } else { Loop = PCMMCIFLoop(Category[i]); if (Loop->GetCategoryID()!=MMCIF_Loop) { RC = CIFRC_NotALoop; delete Category[i]; Loop = new CMMCIFLoop ( CName ); Category[i] = Loop; } } Loop->PutString ( S,TName,nrow ); return RC; } int CMMCIFData::PutLoopReal ( realtype R, cpstr CName, cpstr TName, int nrow, int prec ) { char rS[100]; sprintf ( rS,"%.*g",prec,R ); return PutLoopString ( rS,CName,TName,nrow ); } int CMMCIFData::PutLoopInteger ( int I, cpstr CName, cpstr TName, int nrow ) { char iS[100]; sprintf ( iS,"%i",I ); return PutLoopString ( iS,CName,TName,nrow ); } int CMMCIFData::PutLoopSVector ( psvector S, cpstr CName, cpstr TName, int i1, int i2 ) { // PutLoopSVector(..), PutLoopRVector(..) and PutLoopIVector(..) // put vectors of values into specified loop fields. Parameters i1 // and i2 give the range of indices of values which are to be // transfered. To transfer an entire vector allocated as [0..N-1] // i1 shoudl be set to 0 and i2 - to N-1. Note that the loop is // always indexed as starting form 0 on, therefore negative i1 and // i2 are not allowed, and specifying i1>0 will leave first i1 // elements of the CIF loop for the corresponding tag undefined // (will be output like '?'). PCMMCIFLoop Loop; int i,RC; RC = CIFRC_Ok; // look for category i = AddCategory ( CName ); if (i<0) { // negative value means that the category was not in the list, // but a place for it has been provided and index updated Loop = new CMMCIFLoop ( CName ); Category[nCategories-1] = Loop; } else { Loop = PCMMCIFLoop(Category[i]); if (Loop->GetCategoryID()!=MMCIF_Loop) { RC = CIFRC_NotALoop; delete Category[i]; Loop = new CMMCIFLoop ( CName ); Category[i] = Loop; } } Loop->PutSVector ( S,TName,i1,i2 ); return RC; } int CMMCIFData::PutLoopRVector ( rvector R, cpstr CName, cpstr TName, int i1, int i2, int prec ) { PCMMCIFLoop Loop; int i,RC; RC = CIFRC_Ok; // look for category i = AddCategory ( CName ); if (i<0) { // negative value means that the category was not in the list, // but a place for it has been provided and index updated Loop = new CMMCIFLoop ( CName ); Category[nCategories-1] = Loop; } else { Loop = PCMMCIFLoop(Category[i]); if (Loop->GetCategoryID()!=MMCIF_Loop) { RC = CIFRC_NotALoop; delete Category[i]; Loop = new CMMCIFLoop ( CName ); Category[i] = Loop; } } Loop->PutRVector ( R,TName,i1,i2,prec ); return RC; } int CMMCIFData::PutLoopIVector ( ivector I, cpstr CName, cpstr TName, int i1, int i2 ) { PCMMCIFLoop Loop; int j,RC; RC = CIFRC_Ok; // look for category j = AddCategory ( CName ); if (j<0) { // negative value means that the category was not in the list, // but a place for it has been provided and index updated Loop = new CMMCIFLoop ( CName ); Category[nCategories-1] = Loop; } else { Loop = PCMMCIFLoop(Category[j]); if (Loop->GetCategoryID()!=MMCIF_Loop) { RC = CIFRC_NotALoop; delete Category[j]; Loop = new CMMCIFLoop ( CName ); Category[j] = Loop; } } Loop->PutIVector ( I,TName,i1,i2 ); return RC; } int CMMCIFData::RenameCategory ( cpstr CName, cpstr newCName ) { int i,RC; i = GetCategoryNo ( CName ); if (i>=0) { Category[i]->PutCategoryName ( newCName ); Sort(); RC = CIFRC_Ok; } else RC = CIFRC_NoCategory; return RC; } void CMMCIFData::Copy ( PCMMCIFData Data ) { int i; FreeMemory(0); CreateCopy ( name,Data->name ); nCategories = Data->nCategories; if (nCategories>0) { Category = new PCMMCIFCategory[nCategories]; GetVectorMemory ( index,nCategories,0 ); for (i=0;iCategory[i]) { if (Data->Category[i]->GetCategoryID()==MMCIF_Struct) Category[i] = new CMMCIFStruct(); else Category[i] = new CMMCIFLoop(); Category[i]->Copy ( Data->Category[i] ); } else Category[i] = NULL; index[i] = Data->index[i]; } } flags = Data->flags; Warning = Data->Warning; } int CMMCIFData::CopyCategory ( PCMMCIFData Data, cpstr CName, cpstr newCName ) { PCMMCIFCategory Cat; int i,di,dc,RC; di = Data->GetCategoryNo ( CName ); if (di>=0) { RC = CIFRC_Ok; dc = Data->Category[di]->GetCategoryID(); // look for category i = AddCategory ( CName ); if (i<0) { // negative value means that the category was not in the list, // but a place for it has been provided and index updated if (dc==MMCIF_Loop) Cat = new CMMCIFLoop ( CName ); else Cat = new CMMCIFStruct ( CName ); Category[nCategories-1] = Cat; } else { Cat = Category[i]; if (Cat->GetCategoryID()!=dc) { RC = CIFRC_NotAStructure; delete Category[i]; if (dc==MMCIF_Loop) Cat = new CMMCIFLoop ( CName ); else Cat = new CMMCIFStruct ( CName ); Category[i] = Cat; } } Cat->Copy ( Data->Category[di] ); if (newCName) { Cat->PutCategoryName ( newCName ); Sort(); } } else RC = CIFRC_NoCategory; return RC; } void CMMCIFData::PrintCategories() { // for debuging only int i; printf ( " Total %i categories:\n",nCategories ); for (i=0;iGetCategoryID()==MMCIF_Loop) printf ( "Loop %s\n",Category[i]->name ); else printf ( "Structure %s\n",Category[i]->name ); } } void CMMCIFData::write ( RCFile f ) { int i,k; if (!index) Sort(); f.CreateWrite ( name ); f.WriteInt ( &nCategories ); for (i=0;iGetCategoryID(); f.WriteInt ( &k ); Category[i]->write ( f ); } else { k = -1; f.WriteInt ( &k ); } f.WriteInt ( &(index[i]) ); } f.WriteInt ( &flags ); f.WriteInt ( &Warning ); } void CMMCIFData::read ( RCFile f ) { int i,k; FreeMemory(0); f.CreateRead ( name ); f.ReadInt ( &nCategories ); if (nCategories>0) { Category = new PCMMCIFCategory[nCategories]; GetVectorMemory ( index,nCategories,0 ); for (i=0;i=0) { if (k==MMCIF_Struct) Category[i] = new CMMCIFStruct(); else Category[i] = new CMMCIFLoop(); Category[i]->read ( f ); } else Category[i] = NULL; f.ReadInt ( &(index[i]) ); } } f.ReadInt ( &flags ); f.ReadInt ( &Warning ); } MakeStreamFunctions(CMMCIFData) // ====================== CMMCIFFile ============================= CMMCIFFile::CMMCIFFile() : CStream() { InitMMCIFFile(); } CMMCIFFile::CMMCIFFile ( cpstr FName, byte gzipMode ) : CStream() { InitMMCIFFile (); ReadMMCIFFile ( FName,gzipMode ); } CMMCIFFile::CMMCIFFile ( RPCStream Object ) : CStream(Object) { InitMMCIFFile(); } CMMCIFFile::~CMMCIFFile() { FreeMemory(); } void CMMCIFFile::InitMMCIFFile() { nData = 0; nAllocData = 0; data = NULL; index = NULL; PrintWarnings = False; StopOnWarning = False; } void CMMCIFFile::FreeMemory() { int i; for (i=0;iSetPrintWarnings ( PrintWarnings ); CIF->SetStopOnWarning ( StopOnWarning ); RC = CIF->ReadMMCIFData ( f,S,lcount ); if (!RC) { ExpandData ( nData+1 ); data[nData] = CIF; nData++; CIF = NULL; } } if (CIF) delete CIF; f.shut(); if (RC==CIFRC_NoDataLine) { if (nData>0) RC = 0; } Sort(); return RC; } else return CIFRC_CantOpenFile; } int CMMCIFFile::WriteMMCIFFile ( cpstr FName, byte gzipMode ) { CFile f; f.assign ( FName,True,False,gzipMode ); if (f.rewrite()) { WriteMMCIF ( f ); f.shut(); return 0; } else return CIFRC_CantOpenFile; } void CMMCIFFile::WriteMMCIF ( RCFile f ) { int i; for (i=0;iWriteMMCIF ( f ); } void CMMCIFFile::Sort() { psvector tag; int i; if (nData>0) { FreeVectorMemory ( index,0 ); GetVectorMemory ( index,nData,0 ); GetVectorMemory ( tag ,nData,0 ); for (i=0;iname ); } SortTags ( tag,nData,index ); for (i=0;i=0 : position of the DName found // <0 : the DName was not found, it could be inserted before // (-RC-1)th element, where RC is the return value int l1,l2,l,k; if (!data) return -1; if (!index) Sort(); l = 0; l1 = 0; l2 = nData-1; k = 1; while (l1name ); if (k<0) l2 = l; else if (k>0) l1 = l; else { l1 = l; break; } } if (k==0) return index[l]; // is at RCth position k = strcasecmp ( DName,data[index[l1]]->name ); if (k==0) return index[l1]; // is at RCth position if (k<0) return -1; // would be at (-RC-1)th position if (l2!=l1) { k = strcasecmp ( DName,data[index[l2]]->name ); if (k==0) return index[l2]; // is at RCth position if (k>0) return -2-l2; // would be at l2+1=(-RC-1)th position } return -2-l1; // would be at l1+1=(-RC-1)th position } PCMMCIFData CMMCIFFile::GetCIFData ( int dataNo ) { if ((dataNo>=0) && (dataNo=0) return data[l]; else return NULL; } void CMMCIFFile::ExpandData ( int nDataNew ) { int i,nAD; PPCMMCIFData data1; ivector index1; if (nDataNew>nAllocData) { nAD = nDataNew + IMin(nAllocData/2+1,100); data1 = new PCMMCIFData[nAD]; GetVectorMemory ( index1,nAD,0 ); for (i=0;i=0: the CIF data structure is already in the array // -- its position is returned int i1,i; if (!data) { ExpandData ( 3 ); // get space for first 3 CIF data structures data[0] = new CMMCIFData ( DName ); nData = 1; return -nData; // the CIF data structure has been added // "on the top" of array } i1 = GetCIFDataNo ( DName ); if (i1>=0) return i1; // non-negative returns mean that the CIF // data structure is already in the array i1 = -i1-1; // otherwise the data has to be added and indexed at here // put new CIF data structure on the top of array and update index ExpandData ( nData+1 ); data[nData] = new CMMCIFData ( DName ); for (i=nData;i>i1;i--) index[i] = index[i-1]; index[i1] = nData; nData++; return -nData; // the tag has been added on the top of array } int CMMCIFFile::DeleteMMCIFData ( cpstr DName ) { int dataNo = GetCIFDataNo ( DName ); if (dataNo>=0) return DeleteMMCIFData ( dataNo ); return dataNo; } int CMMCIFFile::DeleteMMCIFData ( int dataNo ) { int i; if ((0<=dataNo) && (dataNonData; nAllocData = nData; if (nData>0) { data = new PCMMCIFData[nData]; for (i=0;idata[i]) { data[i] = new CMMCIFData(); data[i]->Copy ( File->data[i] ); } else data[i] = NULL; } } } void CMMCIFFile::write ( RCFile f ) { int i,k; f.WriteInt ( &nData ); for (i=0;iwrite ( f ); } else { k = 0; f.WriteInt ( &k ); } } void CMMCIFFile::read ( RCFile f ) { int i,k; FreeMemory(); f.ReadInt ( &nData ); nAllocData = nData; if (nData>0) { data = new PCMMCIFData[nData]; for (i=0;iread ( f ); } else data[i] = NULL; } } } MakeStreamFunctions(CMMCIFFile) int isCIF ( cpstr FName, byte gzipMode ) { CFile f; int rc; f.assign ( FName,True,False,gzipMode ); if (f.reset(True)) { rc = isCIF ( f ); f.shut(); } else rc = -1; return rc; } int isCIF ( RCFile f ) { char S[_max_buf_len+1]; Boolean Done; pstr p; f.ReadLine ( S,_max_buf_len ); S[_max_buf_len] = char(0); Done = False; while (!Done) { p = &(S[0]); while ((*p==' ') || (*p==char(9))) p++; Done = !strncmp(p,"data_",5); if (!Done) { if (f.FileEnd()) { Done = True; p = NULL; } else { f.ReadLine ( S,_max_buf_len ); S[_max_buf_len] = char(0); } } } if (!p) return 1; if (!strncmp(p,"data_",5)) return 0; else return 1; } pstr GetCIFMessage ( pstr M, int RC ) { int LineNo; pstr InputLine; InputLine = GetMMCIFInputBuffer ( LineNo ); if (RC>10) { if (RC & CIFW_UnrecognizedItems) sprintf ( M,"unrecognized items found on %ith line\n%s", LineNo,InputLine ); else if (RC & CIFW_MissingField) sprintf ( M,"expected data field not found; line %i reads\n%s", LineNo,InputLine ); else if (RC & CIFW_EmptyLoop) sprintf ( M,"empty loop ('loop_') on %ith line\n%s", LineNo,InputLine ); else if (RC & CIFW_UnexpectedEOF) sprintf ( M,"unexpected end of file; line %i reads\n%s", LineNo,InputLine ); else if (RC & CIFW_LoopFieldMissing) sprintf ( M,"expected data field in a loop not found; " "line %i reads\n%s", LineNo,InputLine ); else if (RC & CIFW_LoopFieldMissing) sprintf ( M,"expected data field in a loop not found; " "line %i reads\n%s", LineNo,InputLine ); else if (RC & CIFW_NotAStructure) sprintf ( M,"a loop is used as a structure on line %i\n%s", LineNo,InputLine ); else if (RC & CIFW_NotALoop) sprintf ( M,"a structure is used as a loop on line %i\n%s", LineNo,InputLine ); else if (RC & CIFW_DuplicateTag) sprintf ( M,"duplicate tag was found on line %i\n%s", LineNo,InputLine ); else sprintf ( M,"undocumented warning issued for line %i\n%s", LineNo,InputLine ); } else if (RC<0) switch (RC) { case CIFRC_StructureNoTag : strcpy(M,"tag of a structure not " "found"); break; case CIFRC_LoopNoTag : strcpy(M,"tag of a loop not found"); break; case CIFRC_NoCategory : strcpy(M,"category not found"); break; case CIFRC_WrongFormat : strcpy(M,"wrong format of a number"); break; case CIFRC_NoTag : strcpy(M,"tag not found"); break; case CIFRC_NotAStructure : strcpy(M,"category is not a " "structure"); break; case CIFRC_NotALoop : strcpy(M,"category is not a loop"); break; case CIFRC_WrongIndex : strcpy(M,"index outside the loop's " "limits"); break; case CIFRC_NoField : strcpy(M,"data is absent"); break; case CIFRC_Created : strcpy(M,"category created"); break; case CIFRC_CantOpenFile : strcpy(M,"can't open CIF file"); break; case CIFRC_NoDataLine : strcpy(M,"'data_' tag not found." ); break; default : strcpy(M,"undocumented return code"); } return M; } mmdb-1.25.5/mmdb/mmdb_cifdefs.cpp0000775000175000017500000001063211736610510013500 00000000000000// $Id: mmdb_cifdefs.cpp,v 1.19 2012/01/26 17:52:20 ekr Exp $ // ================================================================= // // CCP4 Coordinate Library: support of coordinate-related // functionality in protein crystallography applications. // // Copyright (C) Eugene Krissinel 2000-2008. // // This library is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // // ================================================================= // // 08.12.00 <-- Date of Last Modification. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ----------------------------------------------------------------- // // **** Module : MMDBF_Defs // ~~~~~~~~~ // **** Project : MacroMolecular Data Base (MMDB) // ~~~~~~~~~ // // CIF Definitions // // (C) E. Krissinel 2000-2008 // // ================================================================= // #ifndef __MMDB_CIFDefs__ #include "mmdb_cifdefs.h" #endif // ------------------------------------------------------------------ pstr CIFName ( int NameID, int Mode ) { // Gives CIF name according to CIF Mode. switch (Mode) { case CIF_NDB : switch (NameID) { case CAT_POLY_SEQ_SCHEME : return CIFCAT_NDB_POLY_SEQ_SCHEME; case TAG_ID_CODE : return CIFTAG_NDB_PDB_ID_CODE; case TAG_CHAIN_ID : return CIFTAG_NDB_CHAIN_ID; case TAG_SEQ_ALIGN_BEG : return CIFTAG_SEQ_ALIGN_BEG; case TAG_SEQ_ALIGN_BEG_INS_CODE : return CIFTAG_NDB_SEQ_ALIGN_BEG_INS_CODE; case TAG_SEQ_ALIGN_END : return CIFTAG_SEQ_ALIGN_END; case TAG_SEQ_ALIGN_END_INS_CODE : return CIFTAG_NDB_SEQ_ALIGN_END_INS_CODE; case TAG_DB_ACCESSION : return CIFTAG_NDB_DB_ACCESSION; case TAG_DB_ALIGN_BEG : return CIFTAG_DB_ALIGN_BEG; case TAG_DB_ALIGN_BEG_INS_CODE : return CIFTAG_NDB_DB_ALIGN_BEG_INS_CODE; case TAG_DB_ALIGN_END : return CIFTAG_DB_ALIGN_END; case TAG_DB_ALIGN_END_INS_CODE : return CIFTAG_NDB_DB_ALIGN_END_INS_CODE; case TAG_SEQ_CHAIN_ID : return CIFTAG_ID; default : return pstr("ERROR_IN_CIF_NAME_1"); } case CIF_PDBX : switch (NameID) { case CAT_POLY_SEQ_SCHEME : return CIFCAT_PDBX_POLY_SEQ_SCHEME; case TAG_ID_CODE : return CIFTAG_PDBX_PDB_ID_CODE; case TAG_CHAIN_ID : return CIFTAG_PDBX_STRAND_ID; case TAG_SEQ_ALIGN_BEG : return CIFTAG_SEQ_ALIGN_BEG; case TAG_SEQ_ALIGN_BEG_INS_CODE : return CIFTAG_PDBX_SEQ_ALIGN_BEG_INS_CODE; case TAG_SEQ_ALIGN_END : return CIFTAG_SEQ_ALIGN_END; case TAG_SEQ_ALIGN_END_INS_CODE : return CIFTAG_PDBX_SEQ_ALIGN_END_INS_CODE; case TAG_DB_ACCESSION : return CIFTAG_PDBX_DB_ACCESSION; case TAG_DB_ALIGN_BEG : return CIFTAG_DB_ALIGN_BEG; case TAG_DB_ALIGN_BEG_INS_CODE : return CIFTAG_PDBX_DB_ALIGN_BEG_INS_CODE; case TAG_DB_ALIGN_END : return CIFTAG_DB_ALIGN_END; case TAG_DB_ALIGN_END_INS_CODE : return CIFTAG_PDBX_DB_ALIGN_END_INS_CODE; case TAG_SEQ_CHAIN_ID : return CIFTAG_ASYM_ID; default : return pstr("ERROR_IN_CIF_NAME_2"); } default : return pstr("ERROR_IN_CIF_NAME_3"); } } mmdb-1.25.5/mmdb/linalg_.cpp0000775000175000017500000005731411736610510012513 00000000000000// $Id: linalg_.cpp,v 1.21 2012/01/26 17:52:19 ekr Exp $ // ================================================================= // // CCP4 Coordinate Library: support of coordinate-related // functionality in protein crystallography applications. // // Copyright (C) Eugene Krissinel 2000-2008. // // This library is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // // ================================================================= // // 27.06.01 <-- Date of Last Modification. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ----------------------------------------------------------------- // // **** Module : linalg_ // ~~~~~~~~~ // **** Project : MMDB ( MacroMolecular Data Base ) // ~~~~~~~~~ // // (C) E. Krissinel 2000-2008 // // ================================================================= // #include #ifndef __MATH_H #include #endif #ifndef __LinAlg__ #include "linalg_.h" #endif // ========================== Jacobi ============================= void Jacobi ( int N, // dimension of the matrix rmatrix A, // matrix to diagonalize; the lower // triangle, except the diagonal, // will remain unchanged rmatrix T, // eigenvectors placed as columns rvector Eigen, // vector of eigenvalues, orderd // by increasing rvector Aik, // working array int & Signal // 0 <=> Ok, ItMax <=> iteration limit // exchausted. ) { // Diagonalization of symmetric matrices by the method of Jacobi. // Key variables: // ItMax - the maximum available number of iterations // Eps1 - is used in SNA and CSA calculations // Eps2 - is the level of the elimination of the // non-diagonal matrix elements // Eps3 - the criterion to stop the iterations. // The iterations stop if (1-Sigma1/Sigma2)<=Eps3 // where Sigma1 is the dekart norm of the eigenvalues // at the preceding iteration and Sigma2 is // the same for the current iteration. realtype Eps1,Eps2,Eps3; realtype Sigma1,Sigma2,OffDsq, SPQ,CSA,SNA,Q,P, HoldIK,HoldKI; int ItMax; int i,j,k,Iter; Eps1 = 6.0e-9; Eps2 = 9.0e-12; Eps3 = 1.0e-8; ItMax = 9999; Signal = 0; if (N<=1) { T[1][1] = 1.0; Eigen[1] = A[1][1]; return; } for (i=1;i<=N;i++) { for (j=1;j<=N;j++) T[i][j] = 0.0; T[i][i] = 1.0; Eigen[i] = A[i][i]; } Sigma1 = 0.0; OffDsq = 0.0; // Sigma1 is the Dekart measure of the diagonal elements // OffDsq is the Dekart measure of the non-diagonal elements for (i=1;i<=N;i++) { Sigma1 += A[i][i]*A[i][i]; if (iEps3)) { for (i=1;iEps2)) { if (Q>Eps1) { P = 2.0*A[i][j]*(Q/(A[i][i]-A[j][j])); SPQ = sqrt(P*P+Q*Q); CSA = sqrt((1.0+Q/SPQ)/2.0); SNA = P/(SPQ*CSA*2.0); } else { CSA = sqrt(0.5); SNA = CSA; } for (k=1;k<=N;k++) { HoldKI = T[k][i]; T[k][i] = HoldKI*CSA + T[k][j]*SNA; T[k][j] = HoldKI*SNA - T[k][j]*CSA; } for (k=i;k<=N;k++) if (k<=j) { Aik[k] = A[i][k]; A[i][k] = CSA*Aik[k] + SNA*A[k][j]; if (k==j) { A[j][k] = SNA*Aik[k] - CSA*A[j][k]; Aik[j] = SNA*Aik[i] - CSA*Aik[j]; } } else { HoldIK = A[i][k]; A[i][k] = CSA*HoldIK + SNA*A[j][k]; A[j][k] = SNA*HoldIK - CSA*A[j][k]; } for (k=1;k<=j;k++) if (k>i) A[k][j] = SNA*Aik[k] - CSA*A[k][j]; else { HoldKI = A[k][i]; A[k][i] = CSA*HoldKI + SNA*A[k][j]; A[k][j] = SNA*HoldKI - CSA*A[k][j]; } } } Sigma2 = 0.0; for (i=1;i<=N;i++) { Eigen[i] = A[i][i]; Sigma2 += Eigen[i]*Eigen[i]; } HoldIK = fabs(1.0-Sigma1/Sigma2); Sigma1 = Sigma2; Iter++; } if (Iter>ItMax) Signal = ItMax; for (i=1;i<=N;i++) { k = i; for (j=i;j<=N;j++) if (Eigen[j]MaxOffl) MaxOffl = BB; } MaxOffl = sqrt(MaxOffl); } MinL2 = sqrt(MachEps)*MaxOffl; MaxAdd = 0.0; for (j=1;j<=N;j++) { S = 0.0; if (j>1) for (i=1;i1) for (k=1;kMinLjj) MinLjj = BB; } BB = MinLjj/MaxOffl; if (BB>MinL) MinLjj = BB; else MinLjj = MinL; if (L[j][j]>MinLjj*MinLjj) L[j][j] = sqrt(L[j][j]); else { if (MinL2>MinLjj) MinLjj = MinL2; BB = MinLjj*MinLjj-L[j][j]; if (BB>MaxAdd) MaxAdd = BB; L[j][j] = MinLjj; } if (j1) for (i=2;i<=N;i++) { Y[i] = B[i]; for (j=1;j1) for (i=N-1;i>=1;i--) { X[i] = Y[i]; for (j=i+1;j<=N;j++) X[i] -= L[j][i]*X[j]; X[i] /= L[i][i]; } } // ----------------------------------------------------- void ChSolve ( int N, rmatrix L, rvector G, rvector S ) { // A3.2.3 : Solution of the equation L*LT*S = G // by the Cholesky's method //int i; LSolve ( N,L,G,S ); LTSolve ( N,L,S,S ); // for (i=1;i<=N;i++) // S[i] = -S[i]; } // ---------------------------------------------------- void FastInverse ( int N, rmatrix A, ivector J0, //#D realtype & Det, int & Signal ) { // // 17.01.91 <-- Last Date of Modification. // ---------------------------- // // ================================================ // // Fast Inversion of the matrix A // by the method of GAUSS - JOIRDAN . // // ------------------------------------------------ // // Input parameters are : // // N - dimension of the matrix // A - the matrix [1..N][1..N] to be inverted. // // ------------------------------------------------ // // J0 - integer vector [1..N] for temporal storage // // // ------------------------------------------------ // // Output parameters are : // // A - the inverted matrix // Signal - the error key : // = 0 <=> O'K // else // degeneration was found, and // the rang of matrix is Signal-1. // // Variable Det may return the determinant // of matrix A. To obtain it, remove all comments // of form //#D . // // ------------------------------------------------ // // Key Variables are : // // Eps - is the level for the degeneration // detection. Keep in mind, that // this routine does not norm the // matrix given, and thus Eps1 // is the ABSOLUTE value. // // ================================================ // realtype Eps = 1.0e-16; int i,j,k,i0; realtype A0,B; rvector Ai,Ai0; Signal = 0; if (N<=1) { if (fabs(A[1][1])A0) { A0 = fabs(A[j][i]); i0 = j; } } if (A0=1;i--) { j = J0[i]; if (j!=i) { //#D Det = -Det; for (k=1;k<=N;k++) { B = A[k][i]; A[k][i] = A[k][j]; A[k][j] = B; } } } return; } // End of the procedure FastInverse // ---------------------------------------------------- realtype Sign ( realtype A, realtype B ) { if (B>=0.0) return A; else return -A; } realtype SrX2Y2 ( realtype X, realtype Y ) { realtype Ax,Ay; Ax = fabs(X); Ay = fabs(Y); if (Ay>Ax) return Ay*sqrt((X*X)/(Y*Y)+1.0); if (Ay==Ax) return Ax*sqrt(2.0); return Ax*sqrt((Y*Y)/(X*X)+1.0); } // ---------------------------------------------------- void SVD ( int NA, int M, int N, rmatrix A, rmatrix U, rmatrix V, rvector W, rvector RV1, Boolean MatU, Boolean MatV, int & RetCode ) { // // 13.12.01 <-- Last Modification Date // ------------------------ // // ================================================ // // The Singular Value Decomposition // of the matrix A by the algorithm from // G.Forsait, M.Malkolm, K.Mouler. Numerical // methods of mathematical calculations // M., Mir, 1980. // // Matrix A is represented as // // A = U * W * VT // // ------------------------------------------------ // // All dimensions are indexed from 1 on. // // ------------------------------------------------ // // Input parameters: // // NA - number of lines in A. NA may be // equal to M or N only. If NA=M // then usual SVD will be made. If MA=N // then matrix A is transposed before // the decomposition, and the meaning of // output parameters U and V is // swapped (U accepts VT and VT accepts U). // In other words, matrix A has physical // dimension of M x N , same as U and V; // however the logical dimension of it // remains that of N x M . // M - number of lines in U // N - number of columns in U,V and length // of W,RV1 . Always provide M >= N ! // A - matrix [1..M][1..N] or [1..N][1..M] // to be decomposed. The matrix does not // change, and it may coincide with U or // V, if NA=M (in which case A does change) // MatU - compute U , if set True // MatV - compute V , if set True // RV1 - temporary array [1..N]. // U - should be always supplied as an array of // [1..M][1..N], M>=N . // V - should be suuplied as an array of // [1..N][1..N] if MatV is True . // // ------------------------------------------------ // // Output parameters are : // // W - N non-ordered singular values, // if RetCode=0. If RetCode<>0, the // RetCode+1 ... N -th values are still // valid // U - matrix of right singular vectors // (arranged in columns), corresponding // to the singular values in W, if // RetCode=0 and MatU is True. If MatU // is False, U is still used as a // temporary array. If RetCode<>0 then // the RetCode+1 ... N -th vectors // are valid // V - matrix of left singular vectors // (arranged in columns), corresponding // to the singular values in W, if // RetCode=0 and MatV is True. If MatV // is False, V is not used and may be set // to NULL. If RetCode<>0 then the // RetCode+1 ... N -th vectors are valid // RetCode - the error key : // = 0 <=> O'K // else // = k, if the k-th singular value // was not computed after 30 iterations. // // ------------------------------------------------ // // Key Variables are : // // ItnLimit - the limit for iterations // // This routine does not use any machine-dependent // constants. // // ================================================ // // int ItnLimit=300; int i,j,k,l,i1,k1,l1,its,mn,ExitKey; realtype C,G,F,X,S,H,Y,Z,Scale,ANorm,GG; l1 = 0; // this is to keep compiler happy RetCode = 0; if (U!=A) { if (NA==M) for (i=1;i<=M;i++) for (j=1;j<=N;j++) U[i][j] = A[i][j]; else for (i=1;i<=M;i++) for (j=1;j<=N;j++) U[i][j] = A[j][i]; } G = 0.0; Scale = 0.0; ANorm = 0.0; for (i=1;i<=N;i++) { l = i+1; RV1[i] = Scale*G; G = 0.0; S = 0.0; Scale = 0.0; if (i<=M) { for (k=i;k<=M;k++) Scale += fabs(U[k][i]); if (Scale!=0.0) { for (k=i;k<=M;k++) { U[k][i] /= Scale; S += U[k][i]*U[k][i]; } F = U[i][i]; G = -Sign(sqrt(S),F); H = F*G-S; U[i][i] = F-G; if (i!=N) for (j=l;j<=N;j++) { S = 0.0; for (k=i;k<=M;k++) S += U[k][i]*U[k][j]; F = S/H; for (k=i;k<=M;k++) U[k][j] += F*U[k][i]; } for (k=i;k<=M;k++) U[k][i] *= Scale; } } W[i] = Scale*G; G = 0.0; S = 0.0; Scale = 0.0; if ((i<=M) && (i!=N)) { for (k=l;k<=N;k++) Scale += fabs(U[i][k]); if (Scale!=0.0) { for (k=l;k<=N;k++) { U[i][k] /= Scale; S += U[i][k]*U[i][k]; } F = U[i][l]; G = -Sign(sqrt(S),F); H = F*G-S; U[i][l] = F-G; for (k=l;k<=N;k++) RV1[k] = U[i][k]/H; if (i!=M) for (j=l;j<=M;j++) { S = 0.0; for (k=l;k<=N;k++) S += U[j][k]*U[i][k]; for (k=l;k<=N;k++) U[j][k] += S*RV1[k]; } for (k=l;k<=N;k++) U[i][k] *= Scale; } } ANorm = RMax( ANorm,fabs(W[i])+fabs(RV1[i]) ); } // Accumulation of the right-hand transformations if (MatV) for (i=N;i>=1;i--) { if (i!=N) { if (G!=0.0) { for (j=l;j<=N;j++) V[j][i] = (U[i][j]/U[i][l]) / G; for (j=l;j<=N;j++) { S = 0.0; for (k=l;k<=N;k++) S += U[i][k]*V[k][j]; for (k=l;k<=N;k++) V[k][j] += S*V[k][i]; } } for (j=l;j<=N;j++) { V[i][j] = 0.0; V[j][i] = 0.0; } } V[i][i] = 1.0; G = RV1[i]; l = i; } // Accumulation of the left-hand transformations if (MatU) { mn = N; if (M=1;i--) { l = i+1; G = W[i]; if (i!=N) for (j=l;j<=N;j++) U[i][j] = 0.0; if (G!=0.0) { if (i!=mn) for (j=l;j<=N;j++) { S = 0.0; for (k=l;k<=M;k++) S += U[k][i]*U[k][j]; F = (S/U[i][i]) / G; for (k=i;k<=M;k++) U[k][j] += F*U[k][i]; } for (j=i;j<=M;j++) U[j][i] /= G; } else for (j=i;j<=M;j++) U[j][i] = 0.0; U[i][i] += 1.0; } } // Diagonalization of the two-diagonal form. for (k=N;k>=1;k--) { k1 = k-1; its = 0; do { ExitKey = 0; l = k+1; while ((ExitKey==0) && (l>1)) { l--; l1 = l-1; if (fabs(RV1[l])+ANorm==ANorm) ExitKey=1; else if (l1>0) { if (fabs(W[l1])+ANorm==ANorm) ExitKey=2; } } // if (ExitKey!=1) { <-- this is original statement if (ExitKey>1) { // <-- prevents from corruption due to l1<1. // This is a rare case as RV1[1] should be // always 0.0 . Apparently this logics is // on the edge of float-point arithmetic, // therefore extra precaution for the case // of l1<1 was found necessary. C = 0.0; S = 1.0; ExitKey = 0; i = l; while ((ExitKey==0) && (i<=k)) { F = S*RV1[i]; RV1[i] = C*RV1[i]; if (fabs(F)+ANorm==ANorm) ExitKey = 1; else { G = W[i]; H = SrX2Y2(F,G); W[i] = H; C = G/H; S = -F/H; if (MatU) for (j=1;j<=M;j++) { Y = U[j][l1]; Z = U[j][i]; U[j][l1] = Y*C+Z*S; U[j][i] = -Y*S+Z*C; } i++; } } } // Convergence Checking Z = W[k]; if (l!=k) { if (its>=ItnLimit) { RetCode = k; return; } its++; X = W[l]; Y = W[k1]; G = RV1[k1]; H = RV1[k]; F = ((Y-Z)*(Y+Z) + (G-H)*(G+H)) / ( 2.0*H*Y ); if (fabs(F)<=1.0) GG = Sign(sqrt(F*F+1.0),F); else GG = F*sqrt(1.0+1.0/F/F); F = ((X-Z)*(X+Z) + H*(Y/(F+GG)-H)) / X; // Next QR - Transformation C = 1.0; S = 1.0; for (i1=l;i1<=k1;i1++) { i = i1+1; G = RV1[i]; Y = W[i]; H = S*G; G = C*G; Z = SrX2Y2(F,H); RV1[i1] = Z; C = F/Z; S = H/Z; F = X*C+G*S; G = -X*S+G*C; H = Y*S; Y = Y*C; if (MatV) for (j=1;j<=N;j++) { X = V[j][i1]; Z = V[j][i]; V[j][i1] = X*C+Z*S; V[j][i] = -X*S+Z*C; } Z = SrX2Y2(F,H); W[i1] = Z; if (Z!=0.0) { C = F/Z; S = H/Z; } F = C*G+S*Y; X = -S*G+C*Y; if (MatU) for (j=1;j<=M;j++) { Y = U[j][i1]; Z = U[j][i]; U[j][i1] = Y*C+Z*S; U[j][i] = -Y*S+Z*C; } } RV1[l] = 0.0; RV1[k] = F; W[k] = X; } else if (Z<0.0) { W[k] = -Z; if (MatV) for (j=1;j<=N;j++) V[j][k] = -V[j][k]; } } while (l!=k); } } // ----------------------------------------------------- void OrderSVD ( int M, int N, rmatrix U, rmatrix V, rvector W, Boolean MatU, Boolean MatV ) { int i,k,j; realtype P; // External loop of the re-ordering for (i=1;iP) { k = j; P = W[j]; } if (k!=i) { // Swapping the singular value W[k] = W[i]; W[i] = P; // Swapping the U's columns ( if needed ) if (MatU) for (j=1;j<=M;j++) { P = U[j][i]; U[j][i] = U[j][k]; U[j][k] = P; } // Swapping the V's columns ( if needed ) if (MatV) for (j=1;j<=N;j++) { P = V[j][i]; V[j][i] = V[j][k]; V[j][k] = P; } } } } /* #ifndef __STDIO_H #include #endif int main ( int argc, char ** argv, char ** env ) { // Test Jacobi matrix A,T,A1; vector Eigen,Aik; realtype SR; int N,i,j,k,Signal; N = 4; GetMatrixMemory ( A,N,N,1,1 ); GetMatrixMemory ( T,N,N,1,1 ); GetMatrixMemory ( A1,N,N,1,1 ); GetVectorMemory ( Eigen,N,1 ); GetVectorMemory ( Aik ,N,1 ); k = 1; for (i=1;i<=N;i++) for (j=i;j<=N;j++) { A[i][j] = k++; A[i][j] *= 1000.0; A[j][i] = A[i][j]; } printf ( " INITIAL MATRIX:\n" ); for (i=1;i<=N;i++) { for (j=1;j<=N;j++) printf ( " %10.4f",A[i][j] ); printf ( "\n" ); } Jacobi ( N,A,T,Eigen,Aik,Signal ); printf ( "\n EIGEN VALUES AND EIGEN VECTORS:\n" ); for (i=1;i<=N;i++) { printf ( " %10.4f ",Eigen[i] ); for (j=1;j<=N;j++) printf ( " %10.4f",T[j][i] ); printf ( "\n" ); } printf ( "\n measure: " ); for (i=1;i<=N;i++) { SR = 0.0; for (j=1;j<=N;j++) SR += T[j][i]*T[j][i]; printf ( " %10.4f",sqrt(SR) ); } printf ( "\n" ); for (i=1;i<=N;i++) for (j=1;j<=N;j++) { A1[i][j] = 0.0; for (k=1;k<=N;k++) A1[i][j] += T[i][k]*Eigen[k]*T[j][k]; } printf ( "\n RESTORED INITIAL MATRIX:\n" ); for (i=1;i<=N;i++) { for (j=1;j<=N;j++) printf ( " %10.4f",A1[j][i] ); printf ( "\n" ); } FreeMatrixMemory ( A,N,1,1 ); FreeMatrixMemory ( T,N,1,1 ); FreeMatrixMemory ( A1,N,1,1 ); FreeVectorMemory ( Eigen,1 ); FreeVectorMemory ( Aik ,1 ); } */ mmdb-1.25.5/mmdb/mmdb_tables.cpp0000775000175000017500000005525711736610510013363 00000000000000// $Id: mmdb_tables.cpp,v 1.26 2012/01/26 17:52:21 ekr Exp $ // ================================================================= // // CCP4 Coordinate Library: support of coordinate-related // functionality in protein crystallography applications. // // Copyright (C) Eugene Krissinel 2000-2008. // // This library is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // // ================================================================= // // 29.01.10 <-- Date of Last Modification. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ----------------------------------------------------------------- // // **** Module : MMDBF_Tables // ~~~~~~~~~ // **** Project : MacroMolecular Data Base (MMDB) // ~~~~~~~~~ // // **** Functions : // ~~~~~~~~~~~ // // **** Constants : AName ( array of 2-character atom names ) // ~~~~~~~~~~~ HAName ( array of 2=character heteroatom names ) // RName ( 3-characters amino acid names ) // RName1 ( 1-characters amino acid names ) // // // (C) E. Krissinel 2000-2010 // // ================================================================= // #ifndef __STRING_H #include #endif #ifndef __MMDB_Tables__ #include "mmdb_tables.h" #endif #ifndef __MMDB_Defs__ #include "mmdb_defs.h" #endif // ================================================================= cpstr const ElementName[nElementNames] = { " H", "HE", "LI", "BE", " B", " C", " N", " O", " F", "NE", "NA", "MG", "AL", "SI", " P", " S", "CL", "AR", " K", "CA", "SC", "TI", " V", "CR", "MN", "FE", "CO", "NI", "CU", "ZN", "GA", "GE", "AS", "SE", "BR", "KR", "RB", "SR", " Y", "ZR", "NB", "MO", "TC", "RU", "RH", "PD", "AG", "CD", "IN", "SN", "SB", "TE", " I", "XE", "CS", "BA", "LA", "CE", "PR", "ND", "PM", "SM", "EU", "GD", "TB", "DY", "HO", "ER", "TM", "YB", "LU", "HF", "TA", " W", "RE", "OS", "IR", "PT", "AU", "HG", "TL", "PB", "BI", "PO", "AT", "RN", "FR", "RA", "AC", "TH", "PA", " U", "NP", "PU", "AM", "CM", "BK", "CF", "ES", "FM", "MD", "NO", "LR", "RF", "DB", "SG", "BH", "HS", "MT", "UN", "UU", "UB", "UQ", "UH", "UO", " D", "AN" }; realtype const MolecWeight[nElementNames] = { 1.0079, 4.0026, 6.9410, 9.0122, 10.811, 12.011, 14.007, 15.999, 18.998, 20.180, 22.990, 24.305, 26.982, 28.086, 30.974, 32.066, 35.453, 39.948, 39.098, 40.078, 44.956, 47.867, 50.942, 51.996, 54.938, 55.845, 58.993, 58.693, 63.546, 65.390, 69.723, 72.610, 74.922, 78.960, 79.904, 83.800, 85.468, 87.620, 88.906, 91.224, 92.906, 95.940, 97.907, 101.07, 102.91, 106.42, 107.87, 112.41, 114.82, 118.71, 121.76, 127.60, 126.90, 131.29, 132.91, 137.33, 138.91, 140.12, 140.91, 144.24, 144.91, 150.36, 151.96, 157.25, 158.93, 162.50, 164.93, 167.26, 168.93, 173.04, 174.97, 178.49, 180.95, 183.84, 186.21, 190.23, 192.22, 195.08, 196.97, 200.59, 204.38, 207.20, 208.98, 208.98, 209.99, 222.02, 232.02, 226.03, 227.03, 232.04, 231.04, 238.03, 237.05, 244.06, 243.06, 247.07, 247.07, 251.08, 252.08, 257.10, 258.10, 259.10, 262.11, 263.11, 262.11, 266.12, 264.12, 269.13, 268.14, 272.15, 272.15, 277.00, 289.00, 289.00, 293.00, 2.0200, 3.0300 }; realtype const CovalentRadius[nElementNames] = { 0.32, 0.93, 1.23, 0.90, 0.82, 0.77, 0.75, 0.73, 0.72, 0.71, 1.54, 1.36, 1.18, 1.11, 1.06, 1.02, 0.99, 0.98, 2.03, 1.91, 1.62, 1.45, 1.34, 1.18, 1.17, 1.17, 1.16, 1.15, 1.17, 1.25, 1.26, 1.22, 1.20, 1.16, 1.14, 1.12, 2.16, 1.91, 1.62, 1.45, 1.34, 1.30, 1.27, 1.25, 1.25, 1.28, 1.34, 1.48, 1.44, 1.41, 1.40, 1.36, 1.33, 1.31, 2.35, 1.98, 1.69, 1.44, 1.34, 1.30, 1.28, 1.26, 1.27, 1.30, 1.34, 1.49, 1.48, 1.47, 1.46, 1.46, 1.45, 1.43, 2.50, 2.40, 2.20, 1.65, 1.65, 1.64, 1.63, 1.62, 1.85, 1.61, 1.59, 1.59, 1.58, 1.57, 1.56, 1.74, 1.56, 1.65, 1.65, 1.42, 1.65, 1.65, 1.65, 1.65, 1.65, 1.65, 1.65, 1.65, 1.65, 1.65, 1.65, 0.32, 0.10, /**/ 0.20, 0.20, 0.20, 0.20, 0.20, 0.20, 0.20, 0.20, 0.20, 0.20, 0.32, 0.32 }; realtype const VdWaalsRadius[nElementNames] = { 1.20, 1.40, 1.82, 1.78, 1.74, 1.70, 1.55, 1.52, 1.47, 1.54, // ^^^^ ^^^^ <- only a guess 2.27, 1.73, 1.80, 2.10, 1.80, 1.80, 1.75, 1.88, // ^^^^ 2.75, 2.65, // ^^^^ 2.55, 2.45, 2.35, 2.20, 1.73, 1.90, // ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ 1.75, 1.63, 1.40, 1.39, // ^^^^ 1.87, 1.86, 1.85, 1.90, 1.85, 2.02, // ^^^^ 2.75, 2.65, //^^^^ ^^^^ 2.55, 2.45, 2.35, 2.20, 2.05, 1.90, // ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ 1.75, 1.63, 1.72, 1.58, // ^^^^ 1.93, 2.17, 2.10, 2.06, 1.98, 2.16, // ^^^^ 2.75, 2.75, //^^^^ ^^^^ 2.75, 2.75, 2.75, 2.75, 2.75, 2.75, 2.75, // ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ 2.75, 2.75, 2.75, 2.75, 2.75, 2.65, 2.55, // ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ 2.45, 2.35, 2.25, 2.15, 2.05, 1.95, // ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ 1.85, 1.75, 1.66, 1.55, // ^^^^ 1.96, 2.02, 2.00, 2.00, 2.00, 2.00, // ^^^^ ^^^^ ^^^^ ^^^^ 2.75, 2.75, //^^^^ ^^^^ 2.50, 2.25, 1.95, 1.86, 1.80, 1.80, 1.80, // ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ 1.80, 1.80, 1.80, 1.80, 1.80, 1.80, 1.80, // ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ 1.80, 1.80, 1.80, 1.80, 1.80, 1.80, // ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ 1.80, 1.80, 1.80, 1.80, // ^^^^ ^^^^ ^^^^ ^^^^ 1.80, 1.80, 1.80, // ^^^^ ^^^^ ^^^^ 1.30, 1.50 //^^^^ ^^^^ }; realtype const IonicRadius[nElementNames] = { 0.79, 0.49, 2.05, 1.40, 1.17, 0.91, 0.75, 0.65, 0.57, 0.51, 2.23, 1.72, 1.82, 1.46, 1.23, 1.09, 0.97, 0.88, 2.77, 2.23, 2.09, 2.00, 1.92, 1.85, 1.79, 1.72, 1.67, 1.62, 1.57, 1.53, 1.81, 1.52, 1.33, 1.22, 1.12, 1.03, 2.98, 2.45, 2.27, 2.16, 2.09, 2.01, 1.95, 1.89, 1.83, 1.79, 1.75, 1.71, 2.00, 1.72, 1.53, 1.42, 1.32, 1.24, 3.34, 2.78, 2.74, 2.16, 2.09, 2.02, 1.97, 1.92, 1.87, 1.83, 1.79, 1.76, 2.08, 1.81, 1.63, 1.53, 1.43, 1.34, 3.50, 3.00, 3.20, 2.70, 2.67, 2.64, 2.62, 2.59, 2.56, 2.54, 2.51, 2.49, 2.47, 2.45, 2.42, 2.40, 2.25, 3.16, 3.14, 3.11, 3.08, 3.05, 3.02, 2.99, 2.97, 2.95, 2.92, 2.90, 2.87, 2.85 }; cpstr const ElementMetal[nElementMetals] = { "LI", "BE", "NA", "MG", "AL", " K", "CA", "SC", "TI", " V", "MN", "FE", "CO", "NI", "CU", "ZN", "GA", "RB", "SR", " Y", "ZR", "NB", "MO", "TC", "RU", "RH", "PD", "AG", "CD", "IN", "SN", "SB", "CS", "BA", "LA", "CE", "PR", "ND", "PM", "SM", "EU", "GD", "TB", "DY", "HO", "ER", "TM", "YB", "LU", "HF", "TA", " W", "RE", "OS", "IR", "PT", "AU", "HG", "TL", "PB", "BI", "PO", "FR", "RA", "AC", "TH", "PA", " U", "NP", "PU", "AM", "CM", "BK", "CF", "ES", "FM", "MD", "NO", "LR", "RF", "DB", "SG", "BH", "HS", "MT", "UN", "UU", "UB", "UQ", "UH", "UO" }; cpstr const HydAtomName[nHydAtomNames] = { "0H", "1H", "2H", "3H", "4H", "5H", "6H", "7H", "8H", "9H", "HH", "*H", "'H", """H" }; Boolean isMetal ( cpstr element ) { char name[3]; Boolean isThere; int i; if (!element[1]) { name[0] = ' '; name[1] = element[0]; } else strncpy ( name,element,2 ); name[2] = char(0); isThere = False; for (i=0;(i=nElementNames) return ELEMENT_UNKNOWN; return type+1; // so that hydrogen is 1 } realtype getMolecWeight ( cpstr element ) { int type=0; char El[3]; if ((!element[1]) || (element[1]==' ')) { El[0] = ' '; El[1] = element[0]; } else { El[0] = element[0]; El[1] = element[1]; } El[2] = char(0); UpperCase ( El ); while (type=nElementNames) return 1.0; return MolecWeight[type]; } realtype getCovalentRadius ( cpstr element ) { int type=0; char El[3]; if ((!element[1]) || (element[1]==' ')) { El[0] = ' '; El[1] = element[0]; } else { El[0] = element[0]; El[1] = element[1]; } El[2] = char(0); UpperCase ( El ); while (type=nElementNames) return 2.2*CovalentRadius[0]; return CovalentRadius[type]; } realtype getVdWaalsRadius ( cpstr element ) { int type=0; char El[3]; if ((!element[1]) || (element[1]==' ')) { El[0] = ' '; El[1] = element[0]; } else { El[0] = element[0]; El[1] = element[1]; } El[2] = char(0); UpperCase ( El ); while (type=nElementNames) return 1.8; return VdWaalsRadius[type]; } cpstr const ResidueName[nResNames] = { "ALA", "ARG", "ASN", "ASP", "CYS", "CYH", "GLN", "GLU", "GLY", "HIS", "ILE", "LEU", "LYS", "MET", "PHE", "PRO", "SER", "THR", "TRP", "TYR", "VAL", "HEM", "WAT", "SUL", "END", "DUM" }; int getResidueNo ( cpstr resName ) { int i,m; m = -1; for (i=0;(i // ~~~~~~~~~ // **** Project : MacroMolecular Data Base (MMDB) // ~~~~~~~~~ // // **** Classes : CMask ( atom selection mask ) // ~~~~~~~~~ // // (C) E. Krissinel 2000-2010 // // ================================================================= // #ifndef __STRING_H #include #endif #ifndef __STDLIB_H #include #endif #ifndef __MMDB_Mask__ #include "mmdb_mask.h" #endif // ==================== CMask ======================== CMask::CMask() : CStream() { InitMask(); } CMask::CMask ( RPCStream Object ) : CStream(Object) { InitMask(); } CMask::~CMask() { ClearMask(); } void CMask::InitMask() { mlen = 0; m = NULL; } void CMask::SetMaskBit ( int BitNo ) { int n,i; n = BitNo/(8*sizeof(word)); Expand ( n+1 ); i = BitNo - n*(8*sizeof(word)); m[n] |= ((word)1 << i); } void CMask::Expand ( int n ) { wvector m1; int i; if (mlen0)) { nlen = 0; w = 0; while (w==0) { for (i=0;imlen) w |= Mask[i]->m[nlen]; } nlen++; w = ~w; } Expand ( nlen ); i = nlen-1; m[i] = 1; while (!(m[i] & w)) m[i] <<= 1; } else { Expand ( 1 ); m[0] = 1; } } void CMask::CopyMask ( PCMask Mask ) { int i; if (mlen!=Mask->mlen) ClearMask(); if (Mask) { mlen = Mask->mlen; if (mlen>0) { m = new word[mlen]; for (i=0;im[i]; } } } void CMask::SetMask ( PCMask Mask ) { int i; if (Mask) { Expand ( Mask->mlen ); for (i=0;imlen;i++) m[i] |= Mask->m[i]; } } void CMask::RemoveMask ( PCMask Mask ) { int i,l; if (Mask) { l = IMin(mlen,Mask->mlen); for (i=0;im[i]; } } void CMask::SelMask ( PCMask Mask ) { int i,l; if (Mask) { l = IMin(mlen,Mask->mlen); for (i=0;im[i]; for (i=l;imlen ); for (i=0;imlen;i++) m[i] ^= Mask->m[i]; } } void CMask::ClearMask() { if (m) delete[] m; m = NULL; mlen = 0; } void CMask::NegMask() { int i; for (i=0;imlen); while ((im[i]))) i++; return (i0) { m = new word[mlen]; for (i=0;i // ~~~~~~~~~ // **** Project : MacroMolecular Data Base (MMDB) // ~~~~~~~~~ // **** Classes : CChainContainer ( container for in-chain classes ) // ~~~~~~~~~ CContainerChain ( chain containered class template) // CDBReference ( DBREF records ) // CSeqAdv ( SEQADV records ) // CSeqRes ( SEQRES records ) // CModRes ( MODRES records ) // CHetRec ( HET records ) // CChain ( MMDB chain class ) // // Copyright (C) E. Krissinel 2000-2013 // // ================================================================= // #ifndef __STRING_H #include #endif #ifndef __STDLIB_H #include #endif #ifndef __MMDB_Chain__ #include "mmdb_chain.h" #endif #ifndef __MMDB_Model__ #include "mmdb_model.h" #endif #ifndef __MMDB_File__ #include "mmdb_file.h" #endif #ifndef __MMDB_CIFDefs__ #include "mmdb_cifdefs.h" #endif // ================== CProModel ====================== MakeStreamFunctions(CProModel) // ============== CChainContainer ==================== PCContainerClass CChainContainer::MakeContainerClass ( int ClassID ) { switch (ClassID) { default : case ClassID_Template : return CClassContainer::MakeContainerClass(ClassID); case ClassID_DBReference : return new CDBReference ( Chain ); case ClassID_SeqAdv : return new CSeqAdv ( Chain ); case ClassID_ModRes : return new CModRes ( Chain ); case ClassID_Het : return new CHetRec ( Chain ); } } void CChainContainer::SetChain ( PCChain Chain_Owner ) { int i; Chain = Chain_Owner; for (i=0;iSetChain ( Chain ); } cpstr CChainContainer::Get1stChainID() { int i; i = 0; if (Container) { while ((ichainID; else return NULL; } else return NULL; } void CChainContainer::MoveByChainID ( const ChainID chainID, PCChainContainer ChainContainer ) { int i; for (i=0;ichainID,chainID)) { ChainContainer->AddData ( Container[i] ); Container[i] = NULL; } } } MakeStreamFunctions(CChainContainer) // ================ CContainerChain =================== CContainerChain::CContainerChain () : CContainerClass() { Chain = NULL; chainID[0] = char(0); } CContainerChain::CContainerChain ( PCChain Chain_Owner) : CContainerClass() { Chain = Chain_Owner; if (Chain) strcpy ( chainID,Chain->GetChainID() ); else chainID[0] = char(0); } void CContainerChain::SetChain ( PCChain Chain_Owner ) { Chain = Chain_Owner; if (Chain) strcpy ( chainID,Chain->GetChainID() ); else strcpy ( chainID,"" ); } MakeStreamFunctions(CContainerChain) // ================ CDBReference =================== CDBReference::CDBReference() : CContainerChain() { InitDBReference(); } CDBReference::CDBReference( PCChain Chain_Owner ) : CContainerChain(Chain_Owner) { InitDBReference(); } CDBReference::CDBReference ( PCChain Chain_Owner, cpstr S ) : CContainerChain(Chain_Owner) { InitDBReference(); ConvertPDBASCII ( S ); } CDBReference::CDBReference ( RPCStream Object ) : CContainerChain(Object) { InitDBReference(); } CDBReference::~CDBReference() {} void CDBReference::InitDBReference() { seqBeg = 0; strcpy ( insBeg ,"-" ); seqEnd = 0; strcpy ( insEnd ,"-" ); strcpy ( database ,"------" ); strcpy ( dbAccession,"--------" ); strcpy ( dbIdCode ,"------------" ); dbseqBeg = 0; strcpy ( dbinsBeg,"-" ); dbseqEnd = 0; strcpy ( dbinsEnd,"-" ); } void CDBReference::PDBASCIIDump ( pstr S, int N ) { UNUSED_ARGUMENT(N); // makes the ASCII PDB DBREF line number N // from the class' data strcpy ( S,"DBREF" ); PadSpaces ( S,80 ); strcpy_n ( &(S[7]),Chain->GetEntryID(),4 ); if (Chain->chainID[0]) S[12] = Chain->chainID[0]; PutIntIns ( &(S[14]),seqBeg,4,insBeg ); PutIntIns ( &(S[20]),seqEnd,4,insEnd ); strcpy_n ( &(S[26]),database ,6 ); strcpy_n ( &(S[33]),dbAccession,8 ); strcpy_n ( &(S[42]),dbIdCode ,12 ); PutIntIns ( &(S[55]),dbseqBeg,5,dbinsBeg ); PutIntIns ( &(S[62]),dbseqEnd,5,dbinsEnd ); } void CDBReference::MakeCIF ( PCMMCIFData CIF, int N ) { UNUSED_ARGUMENT(N); PCMMCIFLoop Loop1,Loop2; int RC1,RC2; RC1 = CIF->AddLoop ( CIFCAT_STRUCT_REF_SEQ,Loop1 ); RC2 = CIF->AddLoop ( CIFCAT_STRUCT_REF ,Loop2 ); if ((RC1!=CIFRC_Ok) || (RC2!=CIFRC_Ok)) { // the category was (re)created, provide tags Loop1->AddLoopTag ( CIFTAG_NDB_PDB_ID_CODE ); Loop1->AddLoopTag ( CIFTAG_NDB_CHAIN_ID ); Loop1->AddLoopTag ( CIFTAG_SEQ_ALIGN_BEG ); Loop1->AddLoopTag ( CIFTAG_NDB_SEQ_ALIGN_BEG_INS_CODE ); Loop1->AddLoopTag ( CIFTAG_SEQ_ALIGN_END ); Loop1->AddLoopTag ( CIFTAG_NDB_SEQ_ALIGN_END_INS_CODE ); Loop1->AddLoopTag ( CIFTAG_NDB_DB_ACCESSION ); Loop1->AddLoopTag ( CIFTAG_DB_ALIGN_BEG ); Loop1->AddLoopTag ( CIFTAG_NDB_DB_ALIGN_BEG_INS_CODE ); Loop1->AddLoopTag ( CIFTAG_DB_ALIGN_END ); Loop1->AddLoopTag ( CIFTAG_NDB_DB_ALIGN_END_INS_CODE ); Loop2->AddLoopTag ( CIFTAG_DB_NAME ); Loop2->AddLoopTag ( CIFTAG_DB_CODE ); } Loop1->AddString ( Chain->GetEntryID(),True ); Loop1->AddString ( Chain->chainID ,True ); Loop1->AddInteger ( seqBeg ); Loop1->AddString ( insBeg ,True ); Loop1->AddInteger ( seqEnd ); Loop1->AddString ( insEnd ,True ); Loop1->AddString ( dbAccession ,True ); Loop1->AddInteger ( dbseqBeg ); Loop1->AddString ( dbinsBeg ,True ); Loop1->AddInteger ( dbseqEnd ); Loop1->AddString ( dbinsEnd ,True ); Loop2->AddString ( database,True ); Loop2->AddString ( dbIdCode,True ); } void CDBReference::GetCIF ( PCMMCIFData CIF, int & Signal ) { // GetCIF(..) must be always run without reference to Chain, // see CModel::GetCIF(..). PCMMCIFLoop Loop1,Loop2; PCMMCIFStruct Struct2; pstr F; int RC,CIFMode,ref_id1,ref_id2; Loop1 = CIF->GetLoop ( CIFCAT_STRUCT_REF_SEQ ); if (!Loop1) { Signal = -1; return; } if (Signal>=Loop1->GetLoopLength()) { Signal = -1; return; } // Determine the ChainID first and store it locally. It will // be used by CModel for generating chains and placing the // primary structure data BEFORE reading the coordinate section. CIFMode = CIF_NDB; F = Loop1->GetString ( CIFName(TAG_CHAIN_ID,CIFMode),Signal,RC ); if ((RC) || (!F)) { CIFMode = CIF_PDBX; F = Loop1->GetString ( CIFName(TAG_CHAIN_ID,CIFMode),Signal,RC ); } if ((!RC) && F) { strcpy_n0 ( chainID,F,sizeof(ChainID)-1 ); Loop1->DeleteField ( CIFName(TAG_CHAIN_ID,CIFMode),Signal ); } else strcpy ( chainID,"" ); if (CIFGetInteger(seqBeg,Loop1,CIFName(TAG_SEQ_ALIGN_BEG,CIFMode), Signal)) return; CIFGetString ( insBeg,Loop1,CIFName(TAG_SEQ_ALIGN_BEG_INS_CODE,CIFMode), Signal,sizeof(InsCode),pstr(" ") ); if (CIFGetInteger(seqEnd,Loop1,CIFName(TAG_SEQ_ALIGN_END,CIFMode), Signal)) return; CIFGetString ( insEnd,Loop1,CIFName(TAG_SEQ_ALIGN_END_INS_CODE,CIFMode), Signal,sizeof(InsCode),pstr(" ") ); CIFGetString ( dbAccession,Loop1,CIFName(TAG_DB_ACCESSION,CIFMode), Signal,sizeof(DBAcCode),pstr(" ") ); if (CIFGetInteger(dbseqBeg,Loop1,CIFName(TAG_DB_ALIGN_BEG,CIFMode), Signal)) return; CIFGetString ( dbinsBeg,Loop1,CIFName(TAG_DB_ALIGN_BEG_INS_CODE,CIFMode), Signal,sizeof(InsCode),pstr(" ") ); if (CIFGetInteger(dbseqEnd,Loop1,CIFName(TAG_DB_ALIGN_END,CIFMode), Signal)) return; CIFGetString ( dbinsEnd,Loop1,CIFName(TAG_DB_ALIGN_END_INS_CODE,CIFMode), Signal,sizeof(InsCode),pstr(" ") ); Loop2 = CIF->GetLoop ( CIFCAT_STRUCT_REF ); if (Loop2) { CIFGetString ( database,Loop2,CIFTAG_DB_NAME,Signal, sizeof(DBName) ,pstr(" ") ); CIFGetString ( dbIdCode,Loop2,CIFTAG_DB_CODE,Signal, sizeof(DBIdCode),pstr(" ") ); } else if (CIFMode==CIF_PDBX) { Struct2 = CIF->GetStructure ( CIFCAT_STRUCT_REF ); if (Struct2 && (!CIFGetInteger(ref_id1,Loop1,CIFTAG_REF_ID,Signal)) && (!CIFGetInteger(ref_id2,Struct2,CIFTAG_ID,False))) { if (ref_id1==ref_id2) { CIFGetString ( database,Struct2,CIFTAG_DB_NAME, sizeof(DBName) ,pstr(" ") ,False ); CIFGetString ( dbIdCode,Struct2,CIFTAG_DB_CODE, sizeof(DBIdCode),pstr(" "),False ); } } } Signal++; } int CDBReference::ConvertPDBASCII ( cpstr S ) { IDCode idCode; if (Chain->chainID[0]) { if (S[12]!=Chain->chainID[0]) return Error_WrongChainID; } else if (S[12]!=' ') { Chain->chainID[0] = S[12]; Chain->chainID[1] = char(0); } else Chain->chainID[0] = char(0); strcpy ( idCode,Chain->GetEntryID() ); if (idCode[0]) { if (strncmp(&(S[7]),idCode,4) && (!ignoreNonCoorPDBErrors)) return Error_WrongEntryID; } else { GetString ( idCode,&(S[7]),4 ); Chain->SetEntryID ( idCode ); } GetIntIns ( seqBeg,insBeg,&(S[14]),4 ); GetIntIns ( seqEnd,insEnd,&(S[20]),4 ); strcpy_ncs ( database ,&(S[26]),6 ); strcpy_ncs ( dbAccession ,&(S[33]),8 ); strcpy_ncs ( dbIdCode ,&(S[42]),12 ); GetIntIns ( dbseqBeg,dbinsBeg,&(S[55]),5 ); GetIntIns ( dbseqEnd,dbinsEnd,&(S[62]),5 ); return 0; } void CDBReference::Copy ( PCContainerClass DBRef ) { CContainerChain::Copy ( DBRef ); seqBeg = PCDBReference(DBRef)->seqBeg; seqEnd = PCDBReference(DBRef)->seqEnd; dbseqBeg = PCDBReference(DBRef)->dbseqBeg; dbseqEnd = PCDBReference(DBRef)->dbseqEnd; strcpy ( insBeg ,PCDBReference(DBRef)->insBeg ); strcpy ( insEnd ,PCDBReference(DBRef)->insEnd ); strcpy ( database ,PCDBReference(DBRef)->database ); strcpy ( dbAccession,PCDBReference(DBRef)->dbAccession ); strcpy ( dbIdCode ,PCDBReference(DBRef)->dbIdCode ); strcpy ( dbinsBeg ,PCDBReference(DBRef)->dbinsBeg ); strcpy ( dbinsEnd ,PCDBReference(DBRef)->dbinsEnd ); } void CDBReference::write ( RCFile f ) { byte Version=1; f.WriteByte ( &Version ); f.WriteInt ( &seqBeg ); f.WriteInt ( &seqEnd ); f.WriteInt ( &dbseqBeg ); f.WriteInt ( &dbseqEnd ); f.WriteTerLine ( insBeg ,False ); f.WriteTerLine ( insEnd ,False ); f.WriteTerLine ( database ,False ); f.WriteTerLine ( dbAccession,False ); f.WriteTerLine ( dbIdCode ,False ); f.WriteTerLine ( dbinsBeg ,False ); f.WriteTerLine ( dbinsEnd ,False ); } void CDBReference::read ( RCFile f ) { byte Version; f.ReadByte ( &Version ); f.ReadInt ( &seqBeg ); f.ReadInt ( &seqEnd ); f.ReadInt ( &dbseqBeg ); f.ReadInt ( &dbseqEnd ); f.ReadTerLine ( insBeg ,False ); f.ReadTerLine ( insEnd ,False ); f.ReadTerLine ( database ,False ); f.ReadTerLine ( dbAccession,False ); f.ReadTerLine ( dbIdCode ,False ); f.ReadTerLine ( dbinsBeg ,False ); f.ReadTerLine ( dbinsEnd ,False ); } MakeStreamFunctions(CDBReference) // ================ CSeqAdv =================== CSeqAdv::CSeqAdv() : CContainerChain() { InitSeqAdv(); } CSeqAdv::CSeqAdv ( PCChain Chain_Owner ) : CContainerChain(Chain_Owner) { InitSeqAdv(); } CSeqAdv::CSeqAdv ( PCChain Chain_Owner, cpstr S ) : CContainerChain(Chain_Owner) { InitSeqAdv(); ConvertPDBASCII ( S ); } CSeqAdv::CSeqAdv ( RPCStream Object ) : CContainerChain(Object) { InitSeqAdv(); } CSeqAdv::~CSeqAdv() { if (conflict) delete[] conflict; } void CSeqAdv::InitSeqAdv() { strcpy ( resName ,"---" ); seqNum = 0; strcpy ( insCode ,"-" ); strcpy ( database ,"------" ); strcpy ( dbAccession,"---------" ); strcpy ( dbRes ,"---" ); dbSeq = 0; conflict = NULL; CreateCopy ( conflict,pstr(" ") ); } void CSeqAdv::PDBASCIIDump ( pstr S, int N ) { UNUSED_ARGUMENT(N); // makes the ASCII PDB SEQADV line number N // from the class' data strcpy ( S,"SEQADV" ); PadSpaces ( S,80 ); strcpy_n ( &(S[7]) ,Chain->GetEntryID(),4 ); strcpy_n ( &(S[12]),resName ,3 ); if (Chain->chainID[0]) S[16] = Chain->chainID[0]; PutIntIns ( &(S[18]),seqNum,4,insCode ); strcpy_n ( &(S[24]),database ,4 ); strcpy_n ( &(S[29]),dbAccession,9 ); strcpy_n ( &(S[39]),dbRes ,3 ); PutInteger ( &(S[43]),dbSeq ,5 ); strcpy_n ( &(S[49]),conflict,IMin(strlen(conflict),21) ); } int CSeqAdv::ConvertPDBASCII ( cpstr S ) { IDCode idCode; if (Chain->chainID[0]) { if (S[16]!=Chain->chainID[0]) return Error_WrongChainID; } else if (S[16]!=' ') { Chain->chainID[0] = S[16]; Chain->chainID[1] = char(0); } else Chain->chainID[0] = char(0); strcpy ( idCode,Chain->GetEntryID() ); if (idCode[0]) { if (strncmp(&(S[7]),idCode,4) && (!ignoreNonCoorPDBErrors)) return Error_WrongEntryID; } else { GetString ( idCode,&(S[7]),4 ); Chain->SetEntryID ( idCode ); } strcpy_ncs ( resName ,&(S[12]),3 ); GetIntIns ( seqNum,insCode,&(S[18]),4 ); strcpy_ncs ( database ,&(S[24]),4 ); strcpy_ncs ( dbAccession ,&(S[29]),9 ); strcpy_ncs ( dbRes ,&(S[39]),3 ); GetInteger ( dbSeq,&(S[43]),5 ); CreateCopy ( conflict,&(S[49]) ); CutSpaces ( conflict,SCUTKEY_END ); return 0; } void CSeqAdv::MakeCIF ( PCMMCIFData CIF, int N ) { UNUSED_ARGUMENT(N); PCMMCIFLoop Loop; int RC; RC = CIF->AddLoop ( CIFCAT_STRUCT_REF_SEQ_DIF,Loop ); if (RC!=CIFRC_Ok) { // the category was (re)created, provide tags Loop->AddLoopTag ( CIFTAG_NDB_PDB_ID_CODE ); Loop->AddLoopTag ( CIFTAG_MON_ID ); Loop->AddLoopTag ( CIFTAG_NDB_PDB_CHAIN_ID ); Loop->AddLoopTag ( CIFTAG_SEQ_NUM ); Loop->AddLoopTag ( CIFTAG_NDB_PDB_INS_CODE ); Loop->AddLoopTag ( CIFTAG_NDB_SEQ_DB_NAME ); Loop->AddLoopTag ( CIFTAG_NDB_SEQ_DB_ACCESSION_CODE ); Loop->AddLoopTag ( CIFTAG_DB_MON_ID ); Loop->AddLoopTag ( CIFTAG_NDB_SEQ_DB_SEQ_NUM ); Loop->AddLoopTag ( CIFTAG_DETAILS ); } Loop->AddString ( Chain->GetEntryID(),True ); Loop->AddString ( resName ,True ); Loop->AddString ( Chain->chainID ,True ); Loop->AddInteger ( seqNum ); Loop->AddString ( insCode ,True ); Loop->AddString ( database ,True ); Loop->AddString ( dbAccession ,True ); Loop->AddString ( dbRes ,True ); Loop->AddInteger ( dbSeq ); Loop->AddString ( conflict ,True ); } void CSeqAdv::GetCIF ( PCMMCIFData CIF, int & Signal ) { // GetCIF(..) must be always run without reference to Chain, // see CModel::GetCIF(..). PCMMCIFLoop Loop; pstr F; int RC; Loop = CIF->GetLoop ( CIFCAT_STRUCT_REF_SEQ_DIF ); if (!Loop) { Signal = -1; return; } if (Signal>=Loop->GetLoopLength()) { Signal = -1; return; } // Determine the ChainID first and store it locally. It will // be used by CModel for generating chains and placing the // primary structure data BEFORE reading the coordinate section. F = Loop->GetString ( CIFTAG_NDB_PDB_CHAIN_ID,Signal,RC ); if ((!RC) && F) { strcpy_n0 ( chainID,F,sizeof(ChainID)-1 ); Loop->DeleteField ( CIFTAG_NDB_PDB_CHAIN_ID,Signal ); } else strcpy ( chainID,"" ); CIFGetString ( resName,Loop,CIFTAG_MON_ID,Signal,sizeof(ResName), pstr("UNK") ); CIFGetIntegerD ( seqNum,Loop,CIFTAG_SEQ_NUM ); CIFGetString ( insCode,Loop,CIFTAG_NDB_PDB_INS_CODE, Signal,sizeof(InsCode),pstr(" ") ); CIFGetString ( database,Loop,CIFTAG_NDB_SEQ_DB_NAME,Signal, sizeof(DBName),pstr(" ") ); CIFGetString ( dbAccession,Loop,CIFTAG_NDB_SEQ_DB_ACCESSION_CODE, Signal,sizeof(DBAcCode),pstr(" ") ); CIFGetString ( dbRes,Loop,CIFTAG_DB_MON_ID,Signal,sizeof(ResName), pstr(" ") ); CIFGetIntegerD ( dbSeq,Loop,CIFTAG_NDB_SEQ_DB_SEQ_NUM ); // if (CIFGetInteger1(dbSeq,Loop,CIFTAG_NDB_SEQ_DB_SEQ_NUM,Signal)) // dbSeq = MinInt4; F = Loop->GetString ( CIFTAG_DETAILS,Signal,RC ); if ((!RC) && F) { CreateCopy ( conflict,F ); Loop->DeleteField ( CIFTAG_DETAILS,Signal ); } else CreateCopy ( conflict,pstr(" ") ); Signal++; } void CSeqAdv::Copy ( PCContainerClass SeqAdv ) { CContainerClass::Copy ( SeqAdv ); seqNum = PCSeqAdv(SeqAdv)->seqNum; dbSeq = PCSeqAdv(SeqAdv)->dbSeq; strcpy ( resName ,PCSeqAdv(SeqAdv)->resName ); strcpy ( insCode ,PCSeqAdv(SeqAdv)->insCode ); strcpy ( database ,PCSeqAdv(SeqAdv)->database ); strcpy ( dbAccession,PCSeqAdv(SeqAdv)->dbAccession ); strcpy ( dbRes ,PCSeqAdv(SeqAdv)->dbRes ); CreateCopy ( conflict,PCSeqAdv(SeqAdv)->conflict ); } void CSeqAdv::write ( RCFile f ) { byte Version=1; f.WriteByte ( &Version ); f.WriteInt ( &seqNum ); f.WriteInt ( &dbSeq ); f.WriteTerLine ( resName ,False ); f.WriteTerLine ( insCode ,False ); f.WriteTerLine ( database ,False ); f.WriteTerLine ( dbAccession,False ); f.WriteTerLine ( dbRes ,False ); f.CreateWrite ( conflict ); } void CSeqAdv::read ( RCFile f ) { byte Version; f.ReadByte ( &Version ); f.ReadInt ( &seqNum ); f.ReadInt ( &dbSeq ); f.ReadTerLine ( resName ,False ); f.ReadTerLine ( insCode ,False ); f.ReadTerLine ( database ,False ); f.ReadTerLine ( dbAccession,False ); f.ReadTerLine ( dbRes ,False ); f.CreateRead ( conflict ); } MakeStreamFunctions(CSeqAdv) // ================ CSeqRes =================== CSeqRes::CSeqRes() : CStream() { InitSeqRes(); } CSeqRes::CSeqRes ( RPCStream Object ) : CStream(Object) { InitSeqRes(); } CSeqRes::~CSeqRes() { FreeMemory(); } void CSeqRes::SetChain ( PCChain Chain_Owner ) { Chain = Chain_Owner; if (Chain) strcpy ( chainID,Chain->chainID ); else strcpy ( chainID,"" ); } void CSeqRes::InitSeqRes() { Chain = NULL; numRes = -1; resName = NULL; serNum = 0; strcpy ( chainID,"" ); } void CSeqRes::FreeMemory() { if (resName) delete[] resName; resName = NULL; numRes = -1; serNum = 0; } void CSeqRes::PDBASCIIDump ( RCFile f ) { // writes the ASCII PDB SEQRES lines into file f char S[100]; int i,k,sN; if (numRes<0) return; strcpy ( S,"SEQRES" ); PadSpaces ( S,80 ); if (Chain->chainID[0]) S[11] = Chain->chainID[0]; PutInteger ( &(S[13]),numRes,4 ); if (resName) { i = 0; sN = 1; while (ichainID[0]) { if (S[11]!=Chain->chainID[0]) return Error_WrongChainID; } else if (S[11]!=' ') { Chain->chainID[0] = S[11]; Chain->chainID[1] = char(0); } else Chain->chainID[0] = char(0); GetInteger ( sN,&(S[8]) ,2 ); GetInteger ( nR,&(S[13]),4 ); if (sN==0) { FreeMemory(); numRes = nR; } else { serNum++; if (sN!=serNum) return Error_SEQRES_serNum; if (sN==1) { FreeMemory(); resName = new ResName[nR]; for (i=0;i=nR) return Error_SEQRES_extraRes; k = 19; while ((iAddLoop ( CIFCAT_NDB_POLY_SEQ_SCHEME,Loop ); if (RC!=CIFRC_Ok) { // the category was (re)created, provide tags Loop->AddLoopTag ( CIFTAG_ID ); Loop->AddLoopTag ( CIFTAG_MON_ID ); } if (resName) for (i=0;iAddString ( Chain->chainID,True ); Loop->AddString ( resName[i] ,True ); } else for (i=0;iAddString ( Chain->GetEntryID(),True ); Loop->AddString ( pstr("UNK") ,True ); } } int CSeqRes::GetCIF ( PCMMCIFData CIF ) { // Tries to get sequence from the CIF structure. A sequence // for first met chain is extracted and then removed from // the CIF structure, so that sequential calls will extract // all sequencies. Chain ID is stored locally in chainID; // reference to parent chain is neither used nor checked. // Returns 0 if sequence was extracted and 1 otherwise. PCMMCIFLoop Loop; ResName * rN; ChainID chID; pstr F,CHAIN_ID; int RC,CIFMode,i,l; Boolean isMon; FreeMemory(); CIFMode = CIF_NDB; Loop = CIF->GetLoop ( CIFName(CAT_POLY_SEQ_SCHEME,CIFMode) ); if (!Loop) { CIFMode = CIF_PDBX; Loop = CIF->GetLoop ( CIFName(CAT_POLY_SEQ_SCHEME,CIFMode) ); if (!Loop) return 1; } l = Loop->GetLoopLength(); if (l<=0) return 1; rN = new ResName[l]; chainID[0] = char(1); numRes = 0; isMon = False; CHAIN_ID = CIFName(TAG_SEQ_CHAIN_ID,CIFMode); for (i=0;iGetString ( CHAIN_ID,i,RC ); if (!RC) { if (F) strcpy ( chID,F ); else chID[0] = char(0); if (chainID[0]==char(1)) strcpy ( chainID,chID ); if (!strcmp(chainID,chID)) { CIFGetString ( rN[numRes],Loop,CIFTAG_MON_ID,i, sizeof(ResName),pstr("UNK") ); Loop->DeleteField ( CHAIN_ID,i ); if (strcmp(rN[numRes],"UNK")) isMon = True; numRes++; } } } if (numRes==0) { numRes = -1; delete[] rN; return 1; } if (isMon) { resName = new ResName[numRes]; for (i=0;inumRes; serNum = SeqRes->serNum; if (SeqRes->resName) { resName = new ResName[numRes]; for (i=0;iresName[i] ); } } void CSeqRes::write ( RCFile f ) { int i; byte Version=1; f.WriteByte ( &Version ); f.WriteInt ( &numRes ); f.WriteInt ( &serNum ); if (resName) i = 1; else i = 0; f.WriteInt ( &i ); if (resName) for (i=0;iGetEntryID(),4 ); strcpy_n ( &(S[12]),resName ,3 ); if (Chain->chainID[0]) S[16] = Chain->chainID[0]; PutIntIns ( &(S[18]),seqNum,4,insCode ); strcpy_n ( &(S[24]),stdRes ,3 ); strcpy_n ( &(S[29]),comment,IMin(strlen(comment),41) ); } int CModRes::ConvertPDBASCII ( cpstr S ) { IDCode idCode; if (Chain->chainID[0]) { if (S[16]!=Chain->chainID[0]) return Error_WrongChainID; } else if (S[16]!=' ') { Chain->chainID[0] = S[16]; Chain->chainID[1] = char(0); } else Chain->chainID[0] = char(0); strcpy ( idCode,Chain->GetEntryID() ); if (idCode[0]) { if (strncmp(&(S[7]),idCode,4) && (!ignoreNonCoorPDBErrors)) return Error_WrongEntryID; } else { GetString ( idCode,&(S[7]),4 ); Chain->SetEntryID ( idCode ); } GetString ( resName ,&(S[12]),3 ); GetIntIns ( seqNum,insCode,&(S[18]),4 ); GetString ( stdRes ,&(S[24]),3 ); CreateCopy ( comment ,&(S[29]) ); CutSpaces ( comment,SCUTKEY_END ); return 0; } void CModRes::MakeCIF ( PCMMCIFData CIF, int N ) { UNUSED_ARGUMENT(CIF); UNUSED_ARGUMENT(N); /* -- apparently wrong use of _struct_conn, to be revised PCMMCIFLoop Loop; int RC; RC = CIF->AddLoop ( CIFCAT_STRUCT_CONN,Loop ); if (RC!=CIFRC_Ok) { // the category was (re)created, provide tags Loop->AddLoopTag ( CIFTAG_CONN_TYPE_ID ); Loop->AddLoopTag ( CIFTAG_NDB_PDB_ID ); Loop->AddLoopTag ( CIFTAG_PTNR1_LABEL_COMP_ID ); Loop->AddLoopTag ( CIFTAG_PTNR1_LABEL_ASYM_ID ); Loop->AddLoopTag ( CIFTAG_PTNR1_LABEL_SEQ_ID ); Loop->AddLoopTag ( CIFTAG_NDB_PTNR1_LABEL_INS_CODE ); Loop->AddLoopTag ( CIFTAG_NDB_PTNR1_STANDARD_COMP_ID ); Loop->AddLoopTag ( CIFTAG_DETAILS ); } Loop->AddString ( pstr("MODRES") ); Loop->AddString ( Chain->GetEntryID(),True ); Loop->AddString ( resName ,True ); Loop->AddString ( Chain->chainID ,True ); Loop->AddInteger ( seqNum ); Loop->AddString ( insCode ,True ); Loop->AddString ( stdRes ,True ); Loop->AddString ( comment ,True ); */ } void CModRes::GetCIF ( PCMMCIFData CIF, int & Signal ) { UNUSED_ARGUMENT(CIF); // GetCIF(..) must be always run without reference to Chain, // see CModel::GetCIF(..). /* -- apparently wrong use of _struct_conn, to be revised PCMMCIFLoop Loop; pstr F; int l,RC; Loop = CIF->GetLoop ( CIFCAT_STRUCT_CONN ); if (!Loop) { Signal = -1; return; } l = Loop->GetLoopLength(); while (SignalGetString ( CIFTAG_CONN_TYPE_ID,Signal,RC ); if ((!RC) && F) { if (!strcmp(F,"MODRES")) break; } Signal++; } if (Signal>=l) { Signal = -1; return; } Loop->DeleteField ( CIFTAG_CONN_TYPE_ID,Signal ); // Determine the ChainID first and store it locally. It will // be used by CModel for generating chains and placing the // primary structure data BEFORE reading the coordinate section. F = Loop->GetString ( CIFTAG_PTNR1_LABEL_ASYM_ID,Signal,RC ); if ((!RC) && F) { strcpy_n0 ( chainID,F,sizeof(ChainID)-1 ); Loop->DeleteField ( CIFTAG_PTNR1_LABEL_ASYM_ID,Signal ); } else strcpy ( chainID,"" ); CIFGetString ( resName,Loop,CIFTAG_PTNR1_LABEL_COMP_ID,Signal, sizeof(ResName),pstr("UNK") ); if (CIFGetInteger(seqNum,Loop,CIFTAG_PTNR1_LABEL_SEQ_ID,Signal)) return; CIFGetString ( insCode,Loop,CIFTAG_NDB_PTNR1_LABEL_INS_CODE, Signal,sizeof(InsCode),pstr(" ") ); CIFGetString ( stdRes,Loop,CIFTAG_NDB_PTNR1_STANDARD_COMP_ID,Signal, sizeof(ResName),pstr("UNK") ); F = Loop->GetString ( CIFTAG_DETAILS,Signal,RC ); if ((!RC) && F) { CreateCopy ( comment,F ); Loop->DeleteField ( CIFTAG_DETAILS,Signal ); } else CreateCopy ( comment,pstr(" ") ); Signal++; */ Signal = -1; } void CModRes::Copy ( PCContainerClass ModRes ) { seqNum = PCModRes(ModRes)->seqNum; strcpy ( resName,PCModRes(ModRes)->resName ); strcpy ( insCode,PCModRes(ModRes)->insCode ); strcpy ( stdRes ,PCModRes(ModRes)->stdRes ); CreateCopy ( comment,PCModRes(ModRes)->comment ); } void CModRes::write ( RCFile f ) { byte Version=1; f.WriteByte ( &Version ); f.WriteInt ( &seqNum ); f.WriteTerLine ( resName,False ); f.WriteTerLine ( insCode,False ); f.WriteTerLine ( stdRes ,False ); f.CreateWrite ( comment ); } void CModRes::read ( RCFile f ) { byte Version; f.ReadByte ( &Version ); f.ReadInt ( &seqNum ); f.ReadTerLine ( resName,False ); f.ReadTerLine ( insCode,False ); f.ReadTerLine ( stdRes ,False ); f.CreateRead ( comment ); } MakeStreamFunctions(CModRes) // ================ CHetRec ====================== CHetRec::CHetRec() : CContainerChain() { InitHetRec(); } CHetRec::CHetRec ( PCChain Chain_Owner ) : CContainerChain(Chain_Owner) { InitHetRec(); } CHetRec::CHetRec ( PCChain Chain_Owner, cpstr S ) : CContainerChain(Chain_Owner) { InitHetRec(); ConvertPDBASCII ( S ); } CHetRec::CHetRec ( RPCStream Object ) : CContainerChain(Object) { InitHetRec(); } CHetRec::~CHetRec() { if (comment) delete[] comment; } void CHetRec::InitHetRec() { strcpy ( hetID ,"---" ); strcpy ( insCode,"-" ); seqNum = 0; numHetAtoms = 0; comment = NULL; CreateCopy ( comment,pstr(" ") ); } void CHetRec::PDBASCIIDump ( pstr S, int N ) { UNUSED_ARGUMENT(N); // makes the ASCII PDB MODRES line number N // from the class' data strcpy ( S,"HET" ); PadSpaces ( S,80 ); strcpy_n ( &(S[7]) ,hetID,3 ); if (Chain->chainID[0]) S[12] = Chain->chainID[0]; PutIntIns ( &(S[13]),seqNum,4,insCode ); PutInteger ( &(S[20]),numHetAtoms,5 ); strcpy_n ( &(S[30]),comment,IMin(strlen(comment),40) ); } int CHetRec::ConvertPDBASCII ( cpstr S ) { if (Chain->chainID[0]) { if (S[12]!=Chain->chainID[0]) return Error_WrongChainID; } else if (S[12]!=' ') { Chain->chainID[0] = S[12]; Chain->chainID[1] = char(0); } else Chain->chainID[0] = char(0); GetString ( hetID ,&(S[7]) ,3 ); GetIntIns ( seqNum,insCode,&(S[13]),4 ); GetInteger ( numHetAtoms ,&(S[20]),5 ); CreateCopy ( comment ,&(S[30]) ); CutSpaces ( comment,SCUTKEY_END ); return 0; } void CHetRec::MakeCIF ( PCMMCIFData CIF, int N ) { UNUSED_ARGUMENT(N); PCMMCIFLoop Loop; int RC; RC = CIF->AddLoop ( CIFCAT_NDB_NONSTANDARD_LIST,Loop ); if (RC!=CIFRC_Ok) { // the category was (re)created, provide tags Loop->AddLoopTag ( CIFTAG_ID ); Loop->AddLoopTag ( CIFTAG_AUTH_ASYM_ID ); Loop->AddLoopTag ( CIFTAG_AUTH_SEQ_ID ); Loop->AddLoopTag ( CIFTAG_INS_CODE ); Loop->AddLoopTag ( CIFTAG_NUMBER_ATOMS_NH ); Loop->AddLoopTag ( CIFTAG_DETAILS ); } Loop->AddString ( hetID ,True ); Loop->AddString ( Chain->chainID,True ); Loop->AddInteger ( seqNum ); Loop->AddString ( insCode ,True ); Loop->AddInteger ( numHetAtoms ); Loop->AddString ( comment ,True ); } void CHetRec::GetCIF ( PCMMCIFData CIF, int & Signal ) { // GetCIF(..) must be always run without reference to Chain, // see CModel::GetCIF(..). PCMMCIFLoop Loop; pstr F; int RC; Loop = CIF->GetLoop ( CIFCAT_NDB_NONSTANDARD_LIST ); if (!Loop) { Signal = -1; return; } if (Signal>=Loop->GetLoopLength()) { Signal = -1; return; } // Determine the ChainID first and store it locally. It will // be used by CModel for generating chains and placing the // primary structure data BEFORE reading the coordinate section. F = Loop->GetString ( CIFTAG_AUTH_ASYM_ID,Signal,RC ); if ((!RC) && F) { strcpy_n0 ( chainID,F,sizeof(ChainID)-1 ); Loop->DeleteField ( CIFTAG_AUTH_ASYM_ID,Signal ); } else strcpy ( chainID,"" ); CIFGetString ( hetID,Loop,CIFTAG_ID,Signal,sizeof(ResName), pstr("UNK") ); if (CIFGetInteger(seqNum,Loop,CIFTAG_AUTH_SEQ_ID,Signal)) return; CIFGetString ( insCode,Loop,CIFTAG_INS_CODE,Signal,sizeof(InsCode), pstr(" ") ); if (CIFGetInteger(numHetAtoms,Loop,CIFTAG_NUMBER_ATOMS_NH,Signal)) return; F = Loop->GetString ( CIFTAG_DETAILS,Signal,RC ); if ((!RC) && F) { CreateCopy ( comment,F ); Loop->DeleteField ( CIFTAG_DETAILS,Signal ); } else CreateCopy ( comment,pstr(" ") ); Signal++; } void CHetRec::Copy ( PCContainerClass Het ) { seqNum = PCHetRec(Het)->seqNum; numHetAtoms = PCHetRec(Het)->numHetAtoms; strcpy ( hetID ,PCHetRec(Het)->hetID ); strcpy ( insCode,PCHetRec(Het)->insCode ); CreateCopy ( comment,PCHetRec(Het)->comment ); } void CHetRec::write ( RCFile f ) { byte Version=1; f.WriteByte ( &Version ); f.WriteInt ( &seqNum ); f.WriteInt ( &numHetAtoms ); f.WriteTerLine ( hetID ,False ); f.WriteTerLine ( insCode,False ); f.CreateWrite ( comment ); } void CHetRec::read ( RCFile f ) { byte Version; f.ReadByte ( &Version ); f.ReadInt ( &seqNum ); f.ReadInt ( &numHetAtoms ); f.ReadTerLine ( hetID ,False ); f.ReadTerLine ( insCode,False ); f.CreateRead ( comment ); } MakeStreamFunctions(CHetRec) // ===================== CChain ======================= CChain::CChain() : CUDData() { InitChain(); SetChain ( pstr("") ); } CChain::CChain ( PCProModel Model, const ChainID chID ) : CUDData() { InitChain(); SetChain ( chID ); if (Model) Model->AddChain ( this ); } CChain::CChain ( RPCStream Object ) : CUDData(Object) { InitChain(); SetChain ( pstr("") ); } void CChain::InitChain() { nResidues = 0; ResLen = 0; Residue = NULL; model = NULL; chainID[0] = char(0); prevChainID[0] = char(0); nWeights = 0; Weight = 0.0; Exclude = True; } void CChain::SetChain ( const ChainID chID ) { strcpy ( chainID,chID ); if (chID[0]==' ') chainID[0] = char(0); DBReference.SetChain ( this ); SeqAdv .SetChain ( this ); SeqRes .SetChain ( this ); ModRes .SetChain ( this ); Het .SetChain ( this ); } void CChain::SetChainID ( const ChainID chID ) { strcpy ( chainID,chID ); if (chID[0]==' ') chainID[0] = char(0); } CChain::~CChain() { FreeMemory(); if (model) model->_ExcludeChain ( chainID ); } void CChain::FreeMemory() { DeleteAllResidues(); if (Residue) delete[] Residue; ResLen = 0; nResidues = 0; Residue = NULL; FreeAnnotations(); } void CChain::FreeAnnotations() { DBReference.FreeContainer(); SeqAdv .FreeContainer(); SeqRes .FreeMemory (); ModRes .FreeContainer(); Het .FreeContainer(); } void CChain::SetModel ( PCProModel Model ) { model = Model; } PCMMDBManager CChain::GetCoordHierarchy() { if (model) return model->GetCoordHierarchy(); return NULL; } void CChain::CheckInAtoms() { int i; if (GetCoordHierarchy()) for (i=0;iCheckInAtoms(); } int CChain::ConvertDBREF ( cpstr PDBString ) { int RC; PCContainerChain ContainerChain; ContainerChain = new CDBReference(this); RC = ContainerChain->ConvertPDBASCII ( PDBString ); if (RC) { delete ContainerChain; return RC; } DBReference.AddData ( ContainerChain ); return 0; } int CChain::ConvertSEQADV ( cpstr PDBString ) { int RC; PCContainerChain ContainerChain; ContainerChain = new CSeqAdv(this); RC = ContainerChain->ConvertPDBASCII ( PDBString ); if (RC) { delete ContainerChain; return RC; } SeqAdv.AddData ( ContainerChain ); return 0; } int CChain::ConvertSEQRES ( cpstr PDBString ) { return SeqRes.ConvertPDBASCII ( PDBString ); } int CChain::ConvertMODRES ( cpstr PDBString ) { int RC; PCContainerChain ContainerChain; ContainerChain = new CModRes(this); RC = ContainerChain->ConvertPDBASCII ( PDBString ); if (RC) { delete ContainerChain; return RC; } ModRes.AddData ( ContainerChain ); return 0; } int CChain::ConvertHET ( cpstr PDBString ) { int RC; PCContainerChain ContainerChain; ContainerChain = new CHetRec(this); RC = ContainerChain->ConvertPDBASCII ( PDBString ); if (RC) { delete ContainerChain; return RC; } Het.AddData ( ContainerChain ); return 0; } void CChain::PDBASCIIDump ( RCFile f ) { // this function was for test purposes and is not used // for normal function of MMDB DBReference.PDBASCIIDump ( f ); SeqAdv .PDBASCIIDump ( f ); SeqRes .PDBASCIIDump ( f ); ModRes .PDBASCIIDump ( f ); Het .PDBASCIIDump ( f ); } void CChain::PDBASCIIAtomDump ( RCFile f ) { int i; for (i=0;iPDBASCIIAtomDump ( f ); } void CChain::MakeAtomCIF ( PCMMCIFData CIF ) { int i; for (i=0;iMakeAtomCIF ( CIF ); } int CChain::GetNumberOfResidues() { return nResidues; } PCResidue CChain::GetResidue ( int resNo ) { if ((0<=resNo) && (resNoseqNum) && (!strcmp(insCode,Residue[i]->insCode))) { if (!strcmp(resName,Residue[i]->name)) return Residue[i]; // it is there; just return the pointer else if (!Enforce) return NULL; // duplicate seqNum and insCode! } } } else { for (i=0;iseqNum) && (!Residue[i]->insCode[0])) { if (!strcmp(resName,Residue[i]->name)) return Residue[i]; // it is there; just return the pointer else if (!Enforce) return NULL; // duplicate seqNum and insCode! } } } // expand the residue array, if necessary if (nResidues>=ResLen) ExpandResidueArray ( 100 ); // create new residue Residue[nResidues] = newCResidue(); Residue[nResidues]->SetChain ( this ); Residue[nResidues]->SetResID ( resName,seqNum,insCode ); Residue[nResidues]->index = nResidues; nResidues++; return Residue[nResidues-1]; } void CChain::ExpandResidueArray ( int inc ) { PPCResidue Residue1; int i; ResLen += inc; Residue1 = new PCResidue[ResLen]; for (i=0;iseqNum) && (!strcmp(insCode,Residue[i]->insCode))) return Residue[i]; } } else { for (i=0;iseqNum) && (!Residue[i]->insCode[0])) return Residue[i]; } } return NULL; } int CChain::GetResidueNo ( int seqNum, const InsCode insCode ) { // GetResidueNo(..) returns the residue number in the chain's // residues table. Residues are numbered as 0..nres-1 as they appear // in the coordinate file. // If residue is not found, the function returns -1. int i; Boolean isInsCode; if (insCode) isInsCode = insCode[0]!=char(0); else isInsCode = False; if (isInsCode) { for (i=0;iseqNum) && (!strcmp(insCode,Residue[i]->insCode))) return i; } } else { for (i=0;iseqNum) && (!Residue[i]->insCode[0])) return i; } } return -1; } void CChain::GetResidueTable ( PPCResidue & resTable, int & NumberOfResidues ) { resTable = Residue; NumberOfResidues = nResidues; } int CChain::_ExcludeResidue ( const ResName resName, int seqNum, const InsCode insCode ) { // ExcludeResidue(..) excludes (but does not dispose!) a residue // from the chain. Returns 1 if the chain gets empty and 0 otherwise. int i,k; if (!Exclude) return 0; // find the residue k = -1; for (i=0;(iseqNum) && (!strcmp(insCode,Residue[i]->insCode)) && (!strcmp(resName,Residue[i]->name))) k = i; if (k>=0) { for (i=k+1;iindex = i-1; } nResidues--; Residue[nResidues] = NULL; } if (nResidues<=0) return 1; else return 0; } // ------------------ Deleting residues -------------------------- int CChain::DeleteResidue ( int resNo ) { if ((0<=resNo) && (resNoseqNum) && (!strcmp(insCode,Residue[i]->insCode))) { Exclude = False; delete Residue[i]; Residue[i] = NULL; Exclude = True; return 1; } } } else { for (i=0;iseqNum) && (!Residue[i]->insCode[0])) { Exclude = False; delete Residue[i]; Residue[i] = NULL; Exclude = True; return 1; } } } return 0; } int CChain::DeleteAllResidues() { int i,k; Exclude = False; k = 0; for (i=0;iisSolvent()) { delete Residue[i]; Residue[i] = NULL; k++; } } Exclude = True; return k; } void CChain::TrimResidueTable() { int i,j; Exclude = False; j = 0; for (i=0;inAtoms>0) { if (jindex = j; Residue[i] = NULL; } j++; } else { delete Residue[i]; Residue[i] = NULL; } } nResidues = j; Exclude = True; } int CChain::AddResidue ( PCResidue res ) { // modify both CModel::Copy methods simultaneously! // // Copy(PCModel,PPCAtom,int&) copies atoms into array 'atom' // starting from position atom_index. 'atom' should be able to // accept all new atoms - no checks on the length of 'atom' // is being made. This function should not be used in applications. return InsResidue ( res,nResidues ); } /* PCMMDBFile mmdbfile; PCChain chain1; int i; for (i=0;i=ResLen) ExpandResidueArray ( 100 ); if (res->GetCoordHierarchy()) { Residue[nResidues] = newCResidue(); Residue[nResidues]->SetChain ( this ); Residue[nResidues]->SetResID ( res->name,res->seqNum,res->insCode ); if (mmdbfile) { // get space for new atoms mmdbfile->AddAtomArray ( res->GetNumberOfAtoms(True) ); Residue[nResidues]->Copy ( res,mmdbfile->Atom,mmdbfile->nAtoms ); } else { for (i=0;inAtoms;i++) Residue[nResidues]->AddAtom ( res->atom[i] ); } } else { Residue[nResidues] = res; chain1 = res->GetChain(); if (chain1) for (i=0;inResidues;i++) if (chain1->Residue[i]==res) { chain1->Residue[i] = NULL; break; } Residue[nResidues]->SetChain ( this ); if (mmdbfile) Residue[nResidues]->CheckInAtoms(); } nResidues++; } return nResidues; } */ int CChain::InsResidue ( PCResidue res, int seqNum, const InsCode insCode ) { return InsResidue ( res,GetResidueNo(seqNum,insCode) ); } int CChain::InsResidue ( PCResidue res, int pos ) { // Inserts residue res onto position pos of the chain, // pos=0..nResidues-1 . Residues pos..nResidues-1 are // shifted up the chain. // The function places new atoms on the top of atom // index. It is advisable to call // CMMDBFile::PDBCleanup ( PDBCLEAN_INDEX ) after all // insertions are done. PCMMDBFile mmdbfile; PCChain chain1; int i,pp; pp = IMax ( 0,IMin(nResidues,pos) ); for (i=0;i=ResLen) ExpandResidueArray ( 100 ); // shift residues to the end of the chain as necessary for (i=nResidues;i>pp;i--) Residue[i] = Residue[i-1]; // insert the new residue if (res->GetCoordHierarchy()) { Residue[pp] = newCResidue(); Residue[pp]->SetChain ( this ); Residue[pp]->SetResID ( res->name,res->seqNum,res->insCode ); if (mmdbfile) { // get space for new atoms mmdbfile->AddAtomArray ( res->GetNumberOfAtoms(True) ); Residue[pp]->_copy ( res,mmdbfile->Atom,mmdbfile->nAtoms ); } else { for (i=0;inAtoms;i++) Residue[pp]->AddAtom ( res->atom[i] ); } } else { Residue[pp] = res; chain1 = res->GetChain(); if (chain1) for (i=0;inResidues;i++) if (chain1->Residue[i]==res) { chain1->Residue[i] = NULL; break; } Residue[pp]->SetChain ( this ); if (mmdbfile) Residue[pp]->CheckInAtoms(); } nResidues++; } return nResidues; } // -------------------- Extracting atoms ----------------------- int CChain::GetNumberOfAtoms ( Boolean countTers ) { int i,na; na = 0; for (i=0;iGetNumberOfAtoms ( countTers ); return na; } int CChain::GetNumberOfAtoms ( int seqNo, const InsCode insCode ) { PCResidue res; res = GetResidue ( seqNo,insCode ); if (res) return res->nAtoms; return 0; } int CChain::GetNumberOfAtoms ( int resNo ) { if ((0<=resNo) && (resNonAtoms; } return 0; } PCAtom CChain::GetAtom ( int seqNo, const InsCode insCode, const AtomName aname, const Element elmnt, const AltLoc aloc ) { PCResidue res; res = GetResidue ( seqNo,insCode ); if (res) return res->GetAtom ( aname,elmnt,aloc ); return NULL; } PCAtom CChain::GetAtom ( int seqNo, const InsCode insCode, int atomNo ) { PCResidue res; res = GetResidue ( seqNo,insCode ); if (res) { if ((0<=atomNo) && (atomNonAtoms)) return res->atom[atomNo]; } return NULL; } PCAtom CChain::GetAtom ( int resNo, const AtomName aname, const Element elmnt, const AltLoc aloc ) { if ((0<=resNo) && (resNoGetAtom ( aname,elmnt,aloc ); } return NULL; } PCAtom CChain::GetAtom ( int resNo, int atomNo ) { PCResidue res; if ((0<=resNo) && (resNonAtoms)) return res->atom[atomNo]; } } return NULL; } void CChain::GetAtomTable ( int seqNo, const InsCode insCode, PPCAtom & atomTable, int & NumberOfAtoms ) { PCResidue res; atomTable = NULL; NumberOfAtoms = 0; res = GetResidue ( seqNo,insCode ); if (res) { atomTable = res->atom; NumberOfAtoms = res->nAtoms; } } void CChain::GetAtomTable ( int resNo, PPCAtom & atomTable, int & NumberOfAtoms ) { PCResidue res; atomTable = NULL; NumberOfAtoms = 0; if ((0<=resNo) && (resNoatom; NumberOfAtoms = res->nAtoms; } } } void CChain::GetAtomTable1 ( int seqNo, const InsCode insCode, PPCAtom & atomTable, int & NumberOfAtoms ) { PCResidue res; res = GetResidue ( seqNo,insCode ); if (res) res->GetAtomTable1 ( atomTable,NumberOfAtoms ); else { if (atomTable) delete[] atomTable; atomTable = NULL; NumberOfAtoms = 0; } } void CChain::GetAtomTable1 ( int resNo, PPCAtom & atomTable, int & NumberOfAtoms ) { PCResidue res; if ((0<=resNo) && (resNoGetAtomTable1 ( atomTable,NumberOfAtoms ); else { if (atomTable) delete[] atomTable; atomTable = NULL; NumberOfAtoms = 0; } } int CChain::DeleteAtom ( int seqNo, const InsCode insCode, const AtomName aname, const Element elmnt, const AltLoc aloc ) { PCResidue res; res = GetResidue ( seqNo,insCode ); if (res) return res->DeleteAtom ( aname,elmnt,aloc ); return 0; } int CChain::DeleteAtom ( int seqNo, const InsCode insCode, int atomNo ) { PCResidue res; res = GetResidue ( seqNo,insCode ); if (res) return res->DeleteAtom ( atomNo ); return 0; } int CChain::DeleteAtom ( int resNo, const AtomName aname, const Element elmnt, const AltLoc aloc ) { if ((0<=resNo) && (resNoDeleteAtom ( aname,elmnt,aloc ); } return 0; } int CChain::DeleteAtom ( int resNo, int atomNo ) { if ((0<=resNo) && (resNoDeleteAtom ( atomNo ); } return 0; } int CChain::DeleteAllAtoms ( int seqNo, const InsCode insCode ) { PCResidue res; res = GetResidue ( seqNo,insCode ); if (res) return res->DeleteAllAtoms(); return 0; } int CChain::DeleteAllAtoms ( int resNo ) { if ((0<=resNo) && (resNoDeleteAllAtoms(); } return 0; } int CChain::DeleteAllAtoms() { int i,k; k = 0; for (i=0;iDeleteAllAtoms(); return k; } int CChain::DeleteAltLocs() { // This function leaves only alternative location with maximal // occupancy, if those are equal or unspecified, the one with // "least" alternative location indicator. // The function returns the number of deleted. All tables remain // untrimmed, so that explicit trimming or calling FinishStructEdit() // is required. int i,n; n = 0; for (i=0;iDeleteAltLocs(); return n; } int CChain::AddAtom ( int seqNo, const InsCode insCode, PCAtom atom ) { PCResidue res; res = GetResidue ( seqNo,insCode ); if (res) return res->AddAtom ( atom ); return 0; } int CChain::AddAtom ( int resNo, PCAtom atom ) { if ((0<=resNo) && (resNoAddAtom ( atom ); } return 0; } void CChain::Copy ( PCChain Chain ) { // modify both CChain::_copy and CChain::Copy methods simultaneously! int i; FreeMemory(); if (Chain) { CopyAnnotations ( Chain ); nResidues = Chain->nResidues; ResLen = nResidues; if (nResidues>0) { Residue = new PCResidue[nResidues]; for (i=0;iSetChain ( this ); Residue[i]->Copy ( Chain->Residue[i] ); } } } } void CChain::CopyAnnotations ( PCChain Chain ) { if (Chain) { strcpy ( chainID ,Chain->chainID ); strcpy ( prevChainID,Chain->prevChainID ); DBReference.Copy ( &(Chain->DBReference) ); SeqAdv .Copy ( &(Chain->SeqAdv) ); // SEQADV records SeqRes .Copy ( &(Chain->SeqRes) ); // SEQRES data ModRes .Copy ( &(Chain->ModRes) ); // MODRES records Het .Copy ( &(Chain->Het) ); // HET records } } void CChain::_copy ( PCChain Chain ) { // modify both CChain::_copy and CChain::Copy methods simultaneously! int i; FreeMemory(); strcpy ( chainID ,Chain->chainID ); strcpy ( prevChainID,Chain->prevChainID ); DBReference.Copy ( &(Chain->DBReference) ); SeqAdv .Copy ( &(Chain->SeqAdv) ); // SEQADV records SeqRes .Copy ( &(Chain->SeqRes) ); // SEQRES data ModRes .Copy ( &(Chain->ModRes) ); // MODRES records Het .Copy ( &(Chain->Het) ); // HET records nResidues = Chain->nResidues; ResLen = nResidues; if (nResidues>0) { Residue = new PCResidue[nResidues]; for (i=0;iSetChain ( this ); Residue[i]->_copy ( Chain->Residue[i] ); } } } void CChain::_copy ( PCChain Chain, PPCAtom atom, int & atom_index ) { // modify both CChain::_copy and CChain::Copy methods simultaneously! int i; FreeMemory(); strcpy ( chainID ,Chain->chainID ); strcpy ( prevChainID,Chain->prevChainID ); DBReference.Copy ( &(Chain->DBReference) ); SeqAdv .Copy ( &(Chain->SeqAdv) ); // SEQADV records SeqRes .Copy ( &(Chain->SeqRes) ); // SEQRES data ModRes .Copy ( &(Chain->ModRes) ); // MODRES records Het .Copy ( &(Chain->Het) ); // HET records nResidues = Chain->nResidues; ResLen = nResidues; if (nResidues>0) { Residue = new PCResidue[nResidues]; for (i=0;iResidue[i]) { Residue[i] = newCResidue(); Residue[i]->SetChain ( this ); Residue[i]->_copy ( Chain->Residue[i],atom,atom_index ); } else Residue[i] = NULL; } } /* void CChain::Duplicate ( PCChain Chain ) { int i; FreeMemory(); strcpy ( chainID ,Chain->chainID ); strcpy ( prevChainID,Chain->prevChainID ); DBReference.Copy ( &(Chain->DBReference) ); SeqAdv .Copy ( &(Chain->SeqAdv) ); // SEQADV records SeqRes .Copy ( &(Chain->SeqRes) ); // SEQRES data ModRes .Copy ( &(Chain->ModRes) ); // MODRES records Het .Copy ( &(Chain->Het) ); // HET records nResidues = Chain->nResidues; ResLen = nResidues; if (nResidues>0) { Residue = new PCResidue[nResidues]; for (i=0;iSetChain ( this ); Residue[i]->Duplicate ( Chain->Residue[i] ); } } } */ cpstr CChain::GetEntryID() { if (model) return model->GetEntryID(); else return pstr(""); } void CChain::SetEntryID ( const IDCode idCode ) { if (model) model->SetEntryID ( idCode ); } int CChain::GetModelNum() { if (model) return model->GetSerNum(); return 0; } cpstr CChain::GetChainID ( pstr ChID ) { ChID[0] = char(0); if (model) sprintf ( ChID,"/%i/",model->GetSerNum() ); else strcpy ( ChID,"/-/" ); strcat ( ChID,chainID ); return ChID; } void CChain::GetAtomStatistics ( RSAtomStat AS ) { AS.Init(); CalcAtomStatistics ( AS ); AS.Finish(); } void CChain::CalcAtomStatistics ( RSAtomStat AS ) { int i; for (i=0;iCalcAtomStatistics ( AS ); } void CChain::ApplyTransform ( mat44 & TMatrix ) { // transforms all coordinates by multiplying with matrix TMatrix int i; for (i=0;iApplyTransform ( TMatrix ); } Boolean CChain::isSolventChain() { // returns True if chain contains only solvent molecules Boolean B,P; int i; B = True; P = False; for (i=0;(iisSolvent(); } return (B && P); } Boolean CChain::isInSelection ( int selHnd ) { PCMMDBFile mmdbfile = (PCMMDBFile)GetCoordHierarchy(); PCMask Mask; if (mmdbfile) { Mask = mmdbfile->GetSelMask ( selHnd ); if (Mask) return CheckMask ( Mask ); } return False; } Boolean CChain::isAminoacidChain() { // returns True if chain contains at least one aminoacid residue Boolean B,P; int i; B = False; P = False; for (i=0;(iisAminoacid(); } return (B && P); } Boolean CChain::isNucleotideChain() { // returns True if chain contains at least one nucleotide residue Boolean B,P; int i; B = False; P = False; for (i=0;(iisNucleotide(); } return (B && P); } int CChain::CheckID ( const ChainID chID ) { if (chID) { if (!strcmp(chID,chainID)) return 1; } return 0; } int CChain::CheckIDS ( cpstr CID ) { ChainID chn; InsCode inscode; ResName resname; AtomName atm; Element elm; AltLoc aloc; int mdl,sn,rc; rc = ParseAtomPath ( CID,mdl,chn,sn,inscode,resname, atm,elm,aloc,NULL ); if (rc>=0) { if (!strcmp(chn,chainID)) return 1; } return 0; } int CChain::GetNumberOfDBRefs() { return DBReference.Length(); } PCDBReference CChain::GetDBRef ( int dbRefNo ) { return (PCDBReference)DBReference.GetContainerClass ( dbRefNo ); } void CChain::MaskAtoms ( PCMask Mask ) { int i; for (i=0;iMaskAtoms ( Mask ); } void CChain::MaskResidues ( PCMask Mask ) { int i; for (i=0;iSetMask ( Mask ); } void CChain::UnmaskAtoms ( PCMask Mask ) { int i; for (i=0;iUnmaskAtoms ( Mask ); } void CChain::UnmaskResidues ( PCMask Mask ) { int i; for (i=0;iRemoveMask ( Mask ); } // ------- user-defined data handlers int CChain::PutUDData ( int UDDhandle, int iudd ) { if (UDDhandle & UDRF_CHAIN) return CUDData::putUDData ( UDDhandle,iudd ); else return UDDATA_WrongUDRType; } int CChain::PutUDData ( int UDDhandle, realtype rudd ) { if (UDDhandle & UDRF_CHAIN) return CUDData::putUDData ( UDDhandle,rudd ); else return UDDATA_WrongUDRType; } int CChain::PutUDData ( int UDDhandle, cpstr sudd ) { if (UDDhandle & UDRF_CHAIN) return CUDData::putUDData ( UDDhandle,sudd ); else return UDDATA_WrongUDRType; } int CChain::GetUDData ( int UDDhandle, int & iudd ) { if (UDDhandle & UDRF_CHAIN) return CUDData::getUDData ( UDDhandle,iudd ); else return UDDATA_WrongUDRType; } int CChain::GetUDData ( int UDDhandle, realtype & rudd ) { if (UDDhandle & UDRF_CHAIN) return CUDData::getUDData ( UDDhandle,rudd ); else return UDDATA_WrongUDRType; } int CChain::GetUDData ( int UDDhandle, pstr sudd, int maxLen ) { if (UDDhandle & UDRF_CHAIN) return CUDData::getUDData ( UDDhandle,sudd,maxLen ); else return UDDATA_WrongUDRType; } int CChain::GetUDData ( int UDDhandle, pstr & sudd ) { if (UDDhandle & UDRF_CHAIN) return CUDData::getUDData ( UDDhandle,sudd ); else return UDDATA_WrongUDRType; } // ------------------------------------------------------------------- DefineClass(CSortResidues) class CSortResidues : public CQuickSort { public : CSortResidues() : CQuickSort() {} int Compare ( int i, int j ); void Swap ( int i, int j ); void Sort ( PPCResidue res, int nresidues ); }; int CSortResidues::Compare ( int i, int j ) { int diff; diff = ((PPCResidue)data)[i]->seqNum - ((PPCResidue)data)[j]->seqNum; if (diff==0) diff = strcmp( (PPCResidue(data))[i]->insCode, (PPCResidue(data))[j]->insCode ); if (diff>0) return 1; if (diff<0) return -1; return 0; } void CSortResidues::Swap ( int i, int j ) { PCResidue res; res = ((PPCResidue)data)[i]; ((PPCResidue)data)[i] = ((PPCResidue)data)[j]; ((PPCResidue)data)[j] = res; } void CSortResidues::Sort ( PPCResidue res, int nresidues ) { CQuickSort::Sort ( &(res[0]),nresidues ); } void CChain::SortResidues() { CSortResidues SR; TrimResidueTable(); SR.Sort ( Residue,nResidues ); } int CChain::GetNofModResidues() { return ModRes.Length(); } PCModRes CChain::GetModResidue ( int modResNo ) { return PCModRes(ModRes.GetContainerClass(modResNo)); } void CChain::write ( RCFile f ) { int i; byte Version=1; f.WriteByte ( &Version ); CUDData::write ( f ); f.WriteTerLine ( chainID ,False ); f.WriteTerLine ( prevChainID,False ); DBReference.write ( f ); // Database reference SeqAdv .write ( f ); // SEQADV records SeqRes .write ( f ); // SEQRES data ModRes .write ( f ); // MODRES records Het .write ( f ); // HET records f.WriteInt ( &nResidues ); for (i=0;iwrite ( f ); } void CChain::read ( RCFile f ) { // The Atom array in CMMDBFile must be already read // prior to calling this function! int i; byte Version; FreeMemory(); f.ReadByte ( &Version ); CUDData::read ( f ); f.ReadTerLine ( chainID ,False ); f.ReadTerLine ( prevChainID,False ); DBReference.read ( f ); // Database reference SeqAdv .read ( f ); // SEQADV records SeqRes .read ( f ); // SEQRES data ModRes .read ( f ); // MODRES records Het .read ( f ); // HET records SetChain ( chainID ); f.ReadInt ( &nResidues ); ResLen = nResidues; if (nResidues>0) { Residue = new PCResidue[nResidues]; for (i=0;iSetChain ( this ); Residue[i]->read ( f ); } } } MakeFactoryFunctions(CChain) // =================================================================== /* void TestChain() { // reads from 'in.chain', writes into // 'out.chain' and 'abin.chain' CFile f; char S[81]; PCChain Chain; Chain = newCChain(); f.assign ( "in.chain",True ); if (f.reset()) { while (!f.FileEnd()) { f.ReadLine ( S,sizeof(S) ); Chain->ConvertPDBString ( S ); } f.shut(); } else { printf ( " Can't open input file 'in.chain' \n" ); delete Chain; return; } f.assign ( "out.chain",True ); if (f.rewrite()) { Chain->PDBASCIIDump ( f ); f.shut(); } else { printf ( " Can't open output file 'out.chain' \n" ); delete Chain; return; } f.assign ( "mmdb.chain.bin",False ); if (f.rewrite()) { Chain->write ( f ); f.shut(); } else { printf ( " Can't open binary chain file for writing.\n" ); delete Chain; return; } delete Chain; printf ( " Chain deleted.\n" ); Chain = newCChain(); if (f.reset()) { Chain->read ( f ); f.shut(); } else { printf ( " Can't open binary chain file for reading.\n" ); delete Chain; return; } f.assign ( "abin.chain",True ); if (f.rewrite()) { Chain->PDBASCIIDump ( f ); f.shut(); } else printf ( " Can't open output file 'abin.chain' \n" ); delete Chain; } */ mmdb-1.25.5/mmdb/file_.cpp0000775000175000017500000012535512027050103012153 00000000000000// $Id: file_.cpp,v 1.29 2012/01/26 17:52:19 ekr Exp $ // ================================================================= // // CCP4 Coordinate Library: support of coordinate-related // functionality in protein crystallography applications. // // Copyright (C) Eugene Krissinel 2000-2008. // // This library is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // // ================================================================= // // 29.01.10 <-- Date of Last Modification. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ----------------------------------------------------------------- // // **** Module : file_ // ~~~~~~~~~ // **** Classes : CFile - file I/O Support. // ~~~~~~~~~ // // (C) E. Krissinel 2000-2010 // // ================================================================= // #ifndef __STDLIB_H #include #endif #ifdef _WIN32 # include # define sleep Sleep # endif #ifndef __STDIO_H #include #endif #ifndef __STRING_H #include #endif #ifndef _WIN32 #ifndef __UNISTD_H #include #endif #endif #ifndef __File__ #include "file_.h" #endif // _WIN32_NEWLINE should be raised when compilinig on Windows in // order to enforce Windows' line endings when writing text in // files opened for *binary* output. Otherwise, writing text lines // in binary files will results in UNIX line endings. Line endings // in files, opened for output in text mode, will be always // platform-specific. #ifdef _WIN32_NEWLINE // for DOS/WINDOWS machines: #define NEWLINE "\r\n" #else // for UNIX machines: #define NEWLINE "\n" #endif // =================== Auxilary Functions ========================= cpstr GetFPath ( pstr FilePath, int syskey ) { pstr P; if (syskey==syskey_unix) P = strrchr(FilePath,'/'); else if (syskey==syskey_win) P = strrchr(FilePath,'\\'); else if (syskey==syskey_all) { P = strrchr(FilePath,'/'); if (!P) P = strrchr(FilePath,'\\'); } else P = NULL; if (P) { P = P + 1; *P = char(0); } else FilePath[0] = char(0); return FilePath; } cpstr GetFName ( cpstr FilePath, int syskey ) { pstr P; if (syskey==syskey_unix) P = strrchr(FilePath,'/'); else if (syskey==syskey_win) P = strrchr(FilePath,'\\'); else if (syskey==syskey_all) { P = strrchr(FilePath,'/'); if (!P) P = strrchr(FilePath,'\\'); } else P = NULL; if (!P) return FilePath; else return P + 1; } cpstr GetFExt ( cpstr FilePath ) { pstr P; P = strchr ( GetFName(FilePath),'.'); if (!P) return &(FilePath[strlen(FilePath)]); else return P; } cpstr ChangeExt ( pstr FilePath, cpstr newExt, int syskey ) { int i; i = strlen(FilePath)-1; if (syskey==syskey_unix) while ((i>0) && (FilePath[i]!='.') && (FilePath[i]!='/')) i--; else if (syskey==syskey_win) while ((i>0) && (FilePath[i]!='.') && (FilePath[i]!='\\')) i--; else if (syskey==syskey_all) while ((i>0) && (FilePath[i]!='.') && (FilePath[i]!='/') && (FilePath[i]!='\\')) i--; if (FilePath[i]=='.') { FilePath[i+1] = char(0); strcat ( FilePath,newExt ); } else { strcat ( FilePath,"." ); strcat ( FilePath,newExt ); } return FilePath; } Boolean FileExists ( cpstr FileName, PCFile f ) { PCFile g; Boolean B; if (FileName) { if (!f) g = new CFile(); else g = f; g->assign ( FileName ); B = g->exists(); if (!f) delete g; return B; } else return False; } // ======================== CFile Class ======================== #define ARCH_NONE 0 #define ARCH_GZIP 1 #define ARCH_COMPRESS 2 #define ARCH_ENFORCE 3 CFile::CFile ( word BufSize ) { Buf_Size = BufSize; BufLen = 0; BufInc = 1; EofFile = False; hFile = NULL; FName = NULL; BufCnt = 0; IOBuf = NULL; IOSuccess = True; TextMode = False; UniBin = False; StdIO = False; gzipIO = ARCH_NONE; memIO = False; } CFile::~CFile() { shut (); FreeBuffer(); } void CFile::FreeBuffer () { if (IOBuf) { if (!memIO) delete[] IOBuf; IOBuf = NULL; } if (FName) { delete[] FName; FName = NULL; } } void CFile::assign ( cpstr FileName, Boolean Text, Boolean UniB, byte gzMode ) { pstr p; shut(); FreeBuffer(); CreateCopy ( FName,FileName ); StdIO = (!strcmp(FName,"stdin" )) || (!strcmp(FName,"stdout")) || (!strcmp(FName,"stderr")); if (StdIO) TextMode = True; else TextMode = Text; UniBin = UniB; gzipMode = gzMode; gzipIO = ARCH_NONE; if ((gzipMode==GZM_ENFORCE) || (gzipMode==GZM_ENFORCE_GZIP)) gzipIO = ARCH_GZIP; else if (gzipMode==GZM_ENFORCE_COMPRESS) gzipIO = ARCH_COMPRESS; else if (gzipMode==GZM_CHECK) { p = strrchr ( FName,'.' ); if (p) { if (!strcmp(p,".gz")) gzipIO = ARCH_GZIP; else if (!strcmp(p,".Z")) gzipIO = ARCH_COMPRESS; } } memIO = False; } void CFile::assign ( word poolSize, word sizeInc, pstr filePool ) { shut (); FreeBuffer(); IOBuf = (pstr)filePool; BufLen = poolSize; FLength = poolSize; BufInc = sizeInc; BufCnt = 0; memIO = True; gzipMode = GZM_NONE; gzipIO = ARCH_NONE; } void CFile::GetFilePool ( pstr & filePool, word & fileSize ) { if (memIO) { filePool = IOBuf; fileSize = FLength; IOBuf = NULL; BufLen = 0; BufCnt = 0; FLength = 0; } else { filePool = NULL; fileSize = 0; } } static pstr gzip_path = pstr("gzip "); static pstr ungzip_path = pstr("gzip -dc "); static pstr compress_path = pstr("compress "); static pstr uncompress_path = pstr("uncompress -c "); void SetGZIPPath ( pstr gzipPath, pstr ungzipPath ) { if (!gzipPath) gzip_path = pstr("gzip "); else gzip_path = gzipPath; if (!ungzipPath) ungzip_path = pstr("gzip -d "); else ungzip_path = ungzipPath; } void SetCompressPath ( pstr compressPath, pstr uncompressPath ) { if (!compressPath) compress_path = pstr("compress "); else compress_path = compressPath; if (!uncompressPath) uncompress_path = pstr("uncompress -c "); else uncompress_path = uncompressPath; } Boolean CFile::reset ( Boolean ReadOnly, int retry ) { #ifndef _MSC_VER pstr p; int i; #endif if (memIO) { shut(); if (!IOBuf) return False; BufCnt = 0; IOSuccess = True; } else { if (!FName) return False; shut(); BufLen = 0; BufCnt = 0; if (!strcmp(FName,"stdin")) { hFile = stdin; StdIO = True; TextMode = True; FLength = 1; EofFile = False; IOSuccess = True; } else { StdIO = False; if (gzipIO==ARCH_GZIP) { #ifndef _MSC_VER p = NULL; CreateConcat ( p,ungzip_path,FName ); for (i=0;(i<=retry) && (!hFile);i++) { if (i>0) sleep ( 1 ); hFile = popen ( p,"r" ); } if (p) delete[] p; #endif } else if (gzipIO==ARCH_COMPRESS) { #ifndef _MSC_VER p = NULL; CreateConcat ( p,uncompress_path,FName ); for (i=0;(i<=retry) && (!hFile);i++) { if (i>0) sleep ( 1 ); hFile = popen ( p,"r" ); } if (p) delete[] p; #endif } else { #ifndef _MSC_VER for (i=0;(i<=retry) && (!hFile);i++) { if (i>0) sleep ( 1 ); if (TextMode) { if (ReadOnly) hFile = fopen ( FName,"rt" ); else hFile = fopen ( FName,"r+t" ); } else { if (ReadOnly) hFile = fopen ( FName,"rb" ); else hFile = fopen ( FName,"r+b" ); } } #endif } if (hFile) { if (gzipIO==ARCH_NONE) { fseek ( hFile,0L,SEEK_END ); FLength = ftell ( hFile ); fseek ( hFile,0L,SEEK_SET ); EofFile = (FLength<=0); } else { FLength = 1; EofFile = False; } IOSuccess = True; } else { EofFile = True; IOSuccess = False; } } } return IOSuccess; } Boolean CFile::rewrite() { #ifndef _MSC_VER pstr p; #endif if (memIO) { shut(); FreeBuffer(); IOBuf = new char[BufLen]; BufCnt = 0; FLength = 0; IOSuccess = True;; } else { if (!FName) return False; shut(); BufLen = 0; BufCnt = 0; if (gzipIO==ARCH_GZIP) { #ifndef _MSC_VER p = NULL; CreateConcat ( p,gzip_path,pstr(" > "),FName ); hFile = popen ( p,"w" ); if (p) delete[] p; #else hFile = NULL; #endif StdIO = False; } else if (gzipIO==ARCH_COMPRESS) { #ifndef _MSC_VER p = NULL; CreateConcat ( p,compress_path,pstr(" > "),FName ); hFile = popen ( p,"w" ); if (p) delete[] p; #else hFile = NULL; #endif StdIO = False; } else if (!TextMode) { hFile = fopen ( FName,"w+b" ); StdIO = False; } else if (!strcmp(FName,"stdout")) { hFile = stdout; StdIO = True; } else if (!strcmp(FName,"stderr")) { hFile = stderr; StdIO = True; } else { hFile = fopen ( FName,"w+t" ); StdIO = False; } FLength = 0; IOSuccess = (hFile!=NULL); } return IOSuccess; } Boolean CFile::append() { #ifndef _MSC_VER pstr p; #endif if (memIO) { if (!IOBuf) { IOBuf = new char[BufLen]; BufCnt = 0; } FLength = BufCnt; IOSuccess = True; } else { if (!FName) return False; shut(); BufLen = 0; BufCnt = 0; if (gzipIO==ARCH_GZIP) { #ifndef _MSC_VER p = NULL; CreateConcat ( p,gzip_path,pstr(" >> "),FName ); hFile = popen ( p,"w" ); if (p) delete[] p; #else hFile = NULL; #endif StdIO = False; } else if (gzipIO==ARCH_COMPRESS) { #ifndef _MSC_VER p = NULL; CreateConcat ( p,compress_path,pstr(" >> "),FName ); hFile = popen ( p,"w" ); if (p) delete[] p; #else hFile = NULL; #endif StdIO = False; } else if (!TextMode) { hFile = fopen ( FName,"ab" ); StdIO = False; } else if (!strcmp(FName,"stdout")) { hFile = stdout; StdIO = True; } else if (!strcmp(FName,"stderr")) { hFile = stderr; StdIO = True; } else { hFile = fopen ( FName,"at" ); StdIO = False; } FLength = 0; IOSuccess = hFile!=NULL; } return IOSuccess; } Boolean CFile::erase() { if (!FName) return False; shut(); if (!StdIO) { BufLen = 0; BufCnt = 0; if (FName) IOSuccess = (remove(FName)==0); FLength = 0; } else IOSuccess = True; return IOSuccess; } Boolean CFile::exists() { if (memIO) { IOSuccess = (IOBuf!=NULL); } else { if (!FName) return False; shut(); if (!StdIO) { hFile = fopen ( FName,"r" ); IOSuccess = (hFile!=NULL); BufLen = 0; BufCnt = 0; FLength = 0; if (hFile) fclose ( hFile ); } else IOSuccess = True; hFile = NULL; } return IOSuccess; } Boolean CFile::parse ( cpstr FileName ) { UNUSED_ARGUMENT(FileName); return True; } Boolean CFile::rename ( cpstr NewFileName ) { if (!FName) return False; shut(); if (!StdIO) IOSuccess = (::rename(FName,NewFileName)==0); if (IOSuccess) assign ( NewFileName,TextMode,UniBin,gzipMode ); return IOSuccess; } long CFile::Position() { // do not use on text files if (memIO) return BufCnt; if (hFile==NULL) return 0L; return ftell ( hFile ); } Boolean CFile::seek ( long Position ) { // do not use on text files if (memIO) { if (Position<=(long)BufLen) { BufCnt = Position; IOSuccess = True; } else IOSuccess = False; return IOSuccess; } else if (hFile==NULL) return False; else if (!StdIO) { IOSuccess = fseek(hFile,Position,SEEK_SET)==0; return IOSuccess; } else return True; } Boolean CFile::FileEnd() { if (memIO) return ((long)BufCnt>=FLength); if (TextMode) { if (EofFile || ((!hFile) && (!StdIO))) return True; if (feof(hFile)==0) return False; return True; } return EofFile && (BufLen==0); } void CFile::shut () { if (hFile!=NULL) { if (!StdIO) { #ifndef _MSC_VER if (gzipIO!=ARCH_NONE) pclose ( hFile ); else fclose ( hFile ); #else fclose ( hFile ); #endif } hFile = NULL; } } Boolean CFile::isOpen() { if (memIO) return (IOBuf!=NULL); return (hFile!=NULL); } word CFile::ReadLine ( pstr Line, word MaxLen ) { word LCnt; int Done; Boolean HSuccess = IOSuccess; if (memIO) { LCnt = 0; while (((long)BufCnt0) { if ((Line[LCnt-1]!='\n') && (Line[LCnt-1]!='\r')) break; Line[LCnt-1] = char(0); LCnt--; } } else LCnt = 0; return LCnt; } else { if (IOBuf==NULL) { IOBuf = new char[Buf_Size]; BufLen = ReadFile ( IOBuf,Buf_Size ); IOSuccess = HSuccess; BufCnt = 0; } LCnt = 0; do { while ((BufCnt=BufLen) { HSuccess = IOSuccess; BufLen = ReadFile ( IOBuf,Buf_Size ); IOSuccess = HSuccess; BufCnt = 0; } if (IOBuf[BufCnt]=='\r') Done = 1; else if (IOBuf[BufCnt]=='\n') Done = 2; else Done = 0; if (Done) BufCnt++; if (BufCnt>=BufLen) { HSuccess = IOSuccess; BufLen = ReadFile ( IOBuf,Buf_Size ); IOSuccess = HSuccess; BufCnt = 0; } if (BufLen>0) { if (((Done==2) && (IOBuf[BufCnt]=='\r')) || ((Done==1) && (IOBuf[BufCnt]=='\n'))) BufCnt++; } } while ((!Done) && (LCnt0)); Line[LCnt] = char(0); return LCnt; } } } word CFile::ReadNonBlankLine ( pstr S, word MaxLen ) { word i,j; do { j = ReadLine ( S,MaxLen ); i = 0; while ((i=j) && (!FileEnd())); if (i>=j) { S[0] = char(0); j = 0; } return j; } Boolean CFile::WriteLine ( cpstr Line ) { if ((!memIO) && TextMode) { if (hFile==NULL) return False; fputs ( Line,hFile ); // return (fputs(NEWLINE,hFile)>=0); return (fputs("\n",hFile)>=0); } else { if (WriteFile(Line,strlen(Line))) return WriteFile ( (void *)NEWLINE,strlen(NEWLINE) ); else return False; } } Boolean CFile::Write ( cpstr Line ) { if ((!memIO) && TextMode) { if (hFile==NULL) return False; return (fputs(Line,hFile)>=0); } else return WriteFile(Line,strlen(Line)); } Boolean CFile::Write ( realtype V, int length ) { char N[50]; sprintf ( N,"%-.*g",length,V ); if ((!memIO) && TextMode) { if (hFile==NULL) return False; return (fputs(N,hFile)>=0); } else return WriteFile(N,strlen(N)); } Boolean CFile::Write ( int iV, int length ) { char N[50]; sprintf ( N,"%*i",length,iV ); if ((!memIO) && TextMode) { if (hFile==NULL) return False; return (fputs(N,hFile)>=0); } else return WriteFile(N,strlen(N)); } Boolean CFile::LF() { if ((!memIO) && TextMode) { if (hFile==NULL) return False; // return (fputs(NEWLINE,hFile)>=0); return (fputs("\n",hFile)>=0); } else return WriteFile ( (void *)NEWLINE,strlen(NEWLINE) ); } Boolean CFile::WriteDataLine ( realtype X, realtype Y, int length ) { Write ( pstr(" ") ); Write ( X,length ); Write ( pstr(" ") ); Write ( Y,length ); return LF(); } Boolean CFile::WriteParameter ( cpstr S, realtype X, int ParColumn, int length ) { int l=strlen(S); if ((!memIO) && TextMode) { fputs ( S,hFile ); while (lParColumn) { // X = atof ( &(S[ParColumn]) ); X = GetNumber ( &(S[ParColumn]) ); return True; } else { X = 0.0; return False; } } Boolean CFile::ReadParameters ( pstr S, int & n_X, rvector X, int MaxLen, int ParColumn ) { pstr S1,S2; ReadLine ( S,MaxLen ); if ((int)strlen(S)>ParColumn) { n_X = 0; S2 = &(S[ParColumn]); S1 = S2; while (*S1!=char(0)) { if (*S1==',') *S1 = ' '; S1++; } while (*S2!=char(0)) { S1 = S2; X[n_X] = strtod ( S1,&S2 ); n_X++; while ((*S2!=char(0)) && (*S2==' ')) S2++; } return True; } else { n_X = 0; X[0] = 0.0; return False; } } Boolean CFile::ReadParameter ( pstr S, int & X, int ParColumn ) { realtype V; if (ReadParameter(S,V,ParColumn)) { X = mround(V); return True; } else { X = 0; return False; } } Boolean CFile::CreateWrite ( cpstr Line ) { wordUniBin wUB; word i; if (UniBin) { if (Line) { i = strlen(Line)+1; word2UniBin ( i,wUB ); if (WriteFile(wUB,sizeof(wordUniBin))) return WriteFile ( Line,i ); else return False; } else { i = 0; word2UniBin ( i,wUB ); return WriteFile ( wUB,sizeof(wordUniBin) ); } } else { if (Line) { i = strlen(Line)+1; if (WriteFile(&i,sizeof(i))) return WriteFile ( Line,i ); else return False; } else { i = 0; return WriteFile ( &i,sizeof(i) ); } } } #define _max_dyn_string_len 1073741824 word CFile::CreateRead ( pstr & Line ) { wordUniBin wUB; word i; //unsigned short int i; if (Line) { delete[] Line; Line = NULL; } if (UniBin) { ReadFile ( wUB,sizeof(wordUniBin) ); UniBin2word ( wUB,i ); } else ReadFile ( &i,sizeof(i) ); if ((i>0) && (i<_max_dyn_string_len)) { Line = new char[i]; ReadFile ( Line,i ); } return i; } Boolean CFile::WriteTerLine ( cpstr Line, Boolean longLine ) { wordUniBin wUB; word ll; byte sl; Boolean B; if (Line) ll = strlen(Line); else ll = 0; if (!longLine) { sl = byte(ll); B = WriteFile ( &sl,sizeof(sl) ); } else if (UniBin) { word2UniBin ( ll,wUB ); B = WriteFile ( wUB,sizeof(wordUniBin) ); } else B = WriteFile ( &ll,sizeof(ll) ); if (B && (ll>0)) B = WriteFile ( Line,ll ); return B; } word CFile::ReadTerLine ( pstr Line, Boolean longLine ) { wordUniBin wUB; word ll; byte sl; if (!longLine) { ReadFile ( &sl,sizeof(sl) ); ll = sl; } else if (UniBin) { ReadFile ( wUB,sizeof(wordUniBin) ); UniBin2word ( wUB,ll ); } else ReadFile ( &ll,sizeof(ll) ); if (ll>0) ReadFile ( Line,ll ); Line[ll] = char(0); return ll+1; } word CFile::ReadFile ( void * Buffer, word Count ) { word Cnt; if (memIO) { Cnt = WMin(Count,FLength-BufCnt); if (Cnt>0) { memcpy ( Buffer,&(IOBuf[BufCnt]),Cnt ); BufCnt += Cnt; } IOSuccess = (Cnt==Count); EofFile = ((Cnt=FLength)); return Cnt; } else if (hFile) { Cnt = (word)fread ( Buffer,1,Count,hFile ); EofFile = (CntBufLen) { Cnt += BufInc; IOB = new char[Cnt]; if (IOBuf) { memcpy ( IOB,IOBuf,BufCnt ); delete[] IOBuf; } IOBuf = IOB; BufLen = Cnt; } memcpy ( &(IOBuf[BufCnt]),Buffer,Count ); BufCnt += Count; FLength = BufCnt; IOSuccess = True; } else { if (hFile==NULL) return False; Cnt = (word)fwrite ( Buffer,1,Count,hFile ); Pos = Position(); if (Pos>FLength) FLength = Pos; IOSuccess = Cnt==Count; } return IOSuccess; } Boolean CFile::WriteReal ( realtype * V ) { realUniBin rUB; if (UniBin) { real2UniBin ( *V,rUB ); return WriteFile ( rUB,sizeof(realUniBin) ); } else return WriteFile ( V,sizeof(realtype) ); } Boolean CFile::WriteFloat ( realtype * V ) { floatUniBin fUB; float fV; if (UniBin) { float2UniBin ( *V,fUB ); return WriteFile ( fUB,sizeof(floatUniBin) ); } else { fV = (float)*V; return WriteFile ( &fV,sizeof(float) ); } } Boolean CFile::WriteInt ( int * I ) { intUniBin iUB; if (UniBin) { int2UniBin ( *I,iUB ); return WriteFile ( iUB,sizeof(intUniBin) ); } else return WriteFile ( I,sizeof(int) ); } Boolean CFile::WriteShort ( short * S ) { shortUniBin sUB; if (UniBin) { short2UniBin ( *S,sUB ); return WriteFile ( sUB,sizeof(shortUniBin) ); } else return WriteFile ( S,sizeof(short) ); } Boolean CFile::WriteLong ( long * L ) { longUniBin lUB; if (UniBin) { long2UniBin ( *L,lUB ); return WriteFile ( lUB,sizeof(longUniBin) ); } else return WriteFile ( L,sizeof(long) ); } Boolean CFile::WriteBool ( Boolean * B ) { intUniBin iUB; int k; if (UniBin) { if (*B) k = 1; else k = 0; int2UniBin ( k,iUB ); return WriteFile ( iUB,sizeof(intUniBin) ); } else return WriteFile ( B,sizeof(Boolean) ); } Boolean CFile::WriteByte ( byte * B ) { return WriteFile ( B,sizeof(byte) ); } Boolean CFile::WriteWord ( word * W ) { wordUniBin wUB; if (UniBin) { word2UniBin ( *W,wUB ); return WriteFile ( wUB,sizeof(wordUniBin) ); } else return WriteFile ( W,sizeof(word) ); } Boolean CFile::ReadReal ( realtype * V ) { realUniBin rUB; if (UniBin) { if (ReadFile(rUB,sizeof(realUniBin))==sizeof(realUniBin)) { UniBin2real ( rUB,*V ); return True; } else return False; } else return ( ReadFile(V,sizeof(realtype))==sizeof(realtype) ); } Boolean CFile::ReadFloat ( realtype * V ) { floatUniBin fUB; float fV; if (UniBin) { if (ReadFile(fUB,sizeof(floatUniBin))==sizeof(floatUniBin)) { UniBin2float ( fUB,*V ); return True; } } else if (ReadFile(&fV,sizeof(float))==sizeof(float)) { *V = fV; return True; } return False; } Boolean CFile::ReadInt ( int * I ) { intUniBin iUB; if (UniBin) { if (ReadFile(iUB,sizeof(intUniBin))==sizeof(intUniBin)) { UniBin2int ( iUB,*I ); return True; } else return False; } else return ( ReadFile(I,sizeof(int))==sizeof(int) ); } Boolean CFile::ReadShort ( short * S ) { shortUniBin sUB; if (UniBin) { if (ReadFile(sUB,sizeof(shortUniBin))==sizeof(shortUniBin)) { UniBin2short ( sUB,*S ); return True; } else return False; } else return ( ReadFile(S,sizeof(short))==sizeof(short) ); } Boolean CFile::ReadLong ( long * L ) { longUniBin lUB; if (UniBin) { if (ReadFile(lUB,sizeof(longUniBin))==sizeof(longUniBin)) { UniBin2long ( lUB,*L ); return True; } else return False; } else return ( ReadFile(L,sizeof(long))==sizeof(long) ); } Boolean CFile::ReadBool ( Boolean * B ) { intUniBin iUB; int k; if (UniBin) { if (ReadFile(iUB,sizeof(intUniBin))==sizeof(intUniBin)) { UniBin2int ( iUB,k ); *B = (k!=0); return True; } else return False; } else return ( ReadFile(B,sizeof(Boolean))==sizeof(Boolean) ); } Boolean CFile::ReadByte ( byte * B ) { return ( ReadFile(B,sizeof(byte))==sizeof(byte) ); } Boolean CFile::ReadWord ( word * W ) { wordUniBin wUB; if (UniBin) { if (ReadFile(wUB,sizeof(wordUniBin))==sizeof(wordUniBin)) { UniBin2word ( wUB,*W ); return True; } else return False; } else return ( ReadFile(W,sizeof(word))==sizeof(word) ); } Boolean CFile::AddReal ( realtype * V ) { realtype x; if (ReadReal(&x)) { *V += x; return True; } return False; } Boolean CFile::AddFloat ( realtype * V ) { realtype x; if (ReadFloat(&x)) { *V += x; return True; } return False; } Boolean CFile::AddInt ( int * I ) { int k; if (ReadInt(&k)) { *I += k; return True; } return False; } Boolean CFile::AddShort ( short * S ) { short k; if (ReadShort(&k)) { *S += k; return True; } return False; } Boolean CFile::AddLong ( long * L ) { long k; if (ReadLong(&k)) { *L += k; return True; } return False; } Boolean CFile::AddByte ( byte * B ) { byte k; if (ReadByte(&k)) { *B += k; return True; } return False; } Boolean CFile::AddWord ( word * W ) { word k; if (ReadWord(&k)) { *W += k; return True; } return False; } Boolean CFile::WriteVector ( rvector V, int len, int Shift ) { intUniBin iUB; realUniBin rUB; int i; int l = len; if (V==NULL) l = 0; if (UniBin) { int2UniBin ( l,iUB ); WriteFile ( iUB,sizeof(intUniBin) ); for (i=0;i0) WriteFile ( &(V[Shift]),sizeof(realtype)*l ); } return IOSuccess; } Boolean CFile::WriteVector ( ivector iV, int len, int Shift ) { intUniBin iUB; int i; int l = len; if (iV==NULL) l = 0; if (UniBin) { int2UniBin ( l,iUB ); WriteFile ( iUB,sizeof(intUniBin) ); for (i=0;i0) WriteFile ( &(iV[Shift]),sizeof(int)*l ); } return IOSuccess; } Boolean CFile::WriteVector ( lvector lV, int len, int Shift ) { intUniBin iUB; longUniBin lUB; int i; int l = len; if (lV==NULL) l = 0; if (UniBin) { int2UniBin ( l,iUB ); WriteFile ( iUB,sizeof(intUniBin) ); for (i=0;i0) WriteFile ( &(lV[Shift]),sizeof(long)*l ); } return IOSuccess; } Boolean CFile::WriteVector ( bvector B, int len, int Shift ) { intUniBin iUB; int l = len; if (B==NULL) l = 0; if (UniBin) { int2UniBin ( l,iUB ); WriteFile ( iUB,sizeof(intUniBin) ); } else WriteFile ( &l,sizeof(l) ); if (l>0) WriteFile ( &(B[Shift]),sizeof(byte)*l ); return IOSuccess; } Boolean CFile::ReadVector ( rvector V, int maxlen, int Shift ) { intUniBin iUB; realUniBin rUB; int i,l,ll; realtype B; if (UniBin) { ReadFile ( iUB,sizeof(intUniBin) ); UniBin2int ( iUB,l ); if (IOSuccess && (l>0)) { ll = IMin(l,maxlen); if (V) for (i=0;i<=ll;i++) { ReadFile ( rUB,sizeof(realUniBin) ); UniBin2real ( rUB,V[Shift+i] ); } for (i=ll+1;i<=l;i++) ReadFile ( rUB,sizeof(realUniBin) ); } } else { ReadFile ( &l,sizeof(l) ); if (IOSuccess && (l>0)) { ll = IMin(l,maxlen); if (V) ReadFile ( &(V[Shift]),sizeof(realtype)*ll ); for (i=ll+1;i<=l;i++) ReadFile ( &B,sizeof(B) ); } } return IOSuccess; } Boolean CFile::ReadVector ( ivector iV, int maxlen, int Shift ) { intUniBin iUB; int i,l,ll,iB; if (UniBin) { ReadFile ( iUB,sizeof(intUniBin) ); UniBin2int ( iUB,l ); if (IOSuccess && (l>0)) { ll = IMin(l,maxlen); if (iV) for (i=0;i<=ll;i++) { ReadFile ( iUB,sizeof(intUniBin) ); UniBin2int ( iUB,iV[Shift+i] ); } for (i=ll+1;i<=l;i++) ReadFile ( iUB,sizeof(intUniBin) ); } } else { ReadFile ( &l,sizeof(l) ); if (IOSuccess && (l>0)) { ll = IMin(l,maxlen); if (iV) ReadFile ( &(iV[Shift]),sizeof(int)*ll ); for (i=ll+1;i<=l;i++) ReadFile ( &iB,sizeof(iB) ); } } return IOSuccess; } Boolean CFile::ReadVector ( lvector lV, int maxlen, int Shift ) { intUniBin iUB; longUniBin lUB; int i,l,ll; long lB; if (UniBin) { ReadFile ( iUB,sizeof(intUniBin) ); UniBin2int ( iUB,l ); if (IOSuccess && (l>0)) { ll = IMin(l,maxlen); if (lV) for (i=0;i<=ll;i++) { ReadFile ( lUB,sizeof(longUniBin) ); UniBin2long ( lUB,lV[Shift+i] ); } for (i=ll+1;i<=l;i++) ReadFile ( lUB,sizeof(longUniBin) ); } } else { ReadFile ( &l,sizeof(l) ); if (IOSuccess && (l>0)) { ll = IMin(l,maxlen); if (lV) ReadFile ( &(lV[Shift]),sizeof(long)*ll ); for (i=ll+1;i<=l;i++) ReadFile ( &lB,sizeof(lB) ); } } return IOSuccess; } Boolean CFile::ReadVector ( bvector B, int maxlen, int Shift ) { intUniBin iUB; int i,l,ll; byte t; if (UniBin) { ReadFile ( iUB,sizeof(intUniBin) ); UniBin2int ( iUB,l ); } else ReadFile ( &l,sizeof(l) ); if (IOSuccess && (l>0)) { ll = IMin(l,maxlen); if (B) ReadFile ( &(B[Shift]),sizeof(byte)*ll ); for (i=ll+1;i<=l;i++) ReadFile ( &t,sizeof(t) ); } return IOSuccess; } Boolean CFile::CreateReadVector ( rvector & V, int & len, int Shift ) { intUniBin iUB; realUniBin rUB; int i; realtype B; FreeVectorMemory ( V,Shift ); if (UniBin) { ReadFile ( iUB,sizeof(intUniBin) ); UniBin2int ( iUB,len ); if (IOSuccess && (len>0)) { GetVectorMemory ( V,len,Shift ); if (V) for (i=0;i0)) { GetVectorMemory ( V,len,Shift ); if (V) ReadFile ( &(V[Shift]),sizeof(realtype)*len ); else for (i=0;i0)) { GetVectorMemory ( iV,len,Shift ); if (iV) for (i=0;i0)) { GetVectorMemory ( iV,len,Shift ); if (iV) ReadFile ( &(iV[Shift]),sizeof(int)*len ); else for (i=0;i0)) { GetVectorMemory ( lV,len,Shift ); if (lV) for (i=0;i0)) { GetVectorMemory ( lV,len,Shift ); if (lV) ReadFile ( &(lV[Shift]),sizeof(long)*len ); else for (i=0;i0)) { GetVectorMemory ( B,len,Shift ); if (B) ReadFile ( &(B[Shift]),sizeof(byte)*len ); else for (i=0;i0)) { ReadFile ( iUB,sizeof(intUniBin) ); UniBin2int ( iUB,M ); if (IOSuccess && (M>0)) { GetMatrixMemory ( A,N,M,ShiftN,ShiftM ); for (i=0;i0) { ReadFile ( &M,sizeof(M) ); if (M>0) { GetMatrixMemory ( A,N,M,ShiftN,ShiftM ); for (i=0;i=j) DataLen--; if (DataLen>0) { Ok = GetVectorMemory(X,DataLen,Shift); if (Ok && (yCol>=0)) Ok = Ok && GetVectorMemory(Y,DataLen,Shift); if (Ok && (zCol>=0)) Ok = Ok && GetVectorMemory(Z,DataLen,Shift); if (Ok) { reset(); _ReadColumns ( DataLen,S,sizeof(S),X,Y,Z,xCol,yCol, zCol,Shift ); } else ErrCode = FileError_NoMemory; } else ErrCode = FileError_NoDataFound; } else ErrCode = FileError_NoDataFound; return DataLen; } int CFile::CreateReadColumns ( rvector & X, rvector & Y, int xCol, int yCol, int Shift ) { return CreateReadColumns ( X,Y,X,xCol,yCol,-1,Shift ); } void CFile::_ReadColumns ( int & DLen, pstr S, int SLen, rvector X, rvector Y, rvector Z, int xCol, int yCol, int zCol, int Shift ) { int i,is,j,k,m,n,cmax; char SV[256]; realtype Res; ErrCode = 0; i = 0; cmax = IMax(zCol,IMax(xCol,yCol)); while ((i=k)) { DLen = i; return; } m++; } while ((m!=xCol) && (m!=yCol) && (m!=zCol)); if (SV[0]==char(0)) { if (n>0) ErrCode = FileError_NoColumn; else ErrCode = FileError_ShortData; } else { Res = GetNumber ( SV ); if (ErrCode==0) { is = i+Shift; if (m==xCol) X[is] = Res; else if (m==yCol) Y[is] = Res; else Z[is] = Res; n++; } } } if ((ErrCode==0) && (n<2)) ErrCode = FileError_NoColumn; i++; } if ((ErrCode==FileError_ShortData) && (i>1)) { ErrCode = 0; DLen = i-1; } if (ErrCode!=0) ErrCode = FileError_BadData; } void RemoveDelimiters ( pstr S, int SLen ) { int j; for (j=0;j // ~~~~~~~~~ // **** Project : MacroMolecular Data Base (MMDB) // ~~~~~~~~~ // // **** Classes : CSymOp ( symmetry operator ) // ~~~~~~~~~ // // (C) E. Krissinel 2000-2010 // // ================================================================= // #ifndef __STRING_H #include #endif #ifndef __STDLIB_H #include #endif #ifndef __MATH_H #include #endif #ifndef __MMDB_SymOp__ #include "mmdb_symop.h" #endif // ==================== CSymOp ======================== CSymOp::CSymOp() : CStream() { InitSymOp(); } CSymOp::CSymOp ( RPCStream Object ) : CStream(Object) { InitSymOp(); } CSymOp::~CSymOp() { FreeMemory(); } void CSymOp::InitSymOp() { int i,j; XYZOp = NULL; for (i=0;i<4;i++) { for (j=0;j<4;j++) T[i][j] = 0.0; T[i][i] = 1.0; } } void CSymOp::FreeMemory() { if (XYZOp) delete[] XYZOp; XYZOp = NULL; } int CSymOp::SetSymOp ( cpstr XYZOperation ) { int i,j; CreateCopy ( XYZOp,XYZOperation ); DelSpaces ( XYZOp ); for (i=0;i<4;i++) for (j=0;j<4;j++) T[i][j] = 0.0; i = GetOperation ( 0 ); if (!i) i = GetOperation ( 1 ); if (!i) i = GetOperation ( 2 ); T[3][3] = 1.0; return i; } pstr CSymOp::GetSymOp() { if (XYZOp) return XYZOp; else return pstr(""); } int CSymOp::GetOperation ( int n ) { char L[100]; pstr p1,p2; int len; realtype V; p1 = XYZOp; p2 = strchr ( p1,',' ); if (!p2) return SYMOP_WrongSyntax; if (n>0) { p1 = p2+1; p2 = strchr ( p1,',' ); if (!p2) return SYMOP_WrongSyntax; } if (n>1) { p1 = p2+1; p2 = NULL; } if (p2) *p2 = char(0); strcpy ( L,p1 ); if (p2) *p2 = ','; DelSpaces ( L ); if (!L[0]) return SYMOP_WrongSyntax; UpperCase ( L ); len = strlen ( L ); T[n][0] = 0.0; if (L[0]=='X') { T[n][0] += 1.0; L[0] = ' '; } do { p1 = strstr ( L,"+X" ); if (p1) { T[n][0] += 1.0; strncpy ( p1," ",2 ); } } while (p1); do { p1 = strstr ( L,"-X" ); if (p1) { T[n][0] -= 1.0; strncpy ( p1," ",2 ); } } while (p1); T[n][1] = 0.0; if (L[0]=='Y') { T[n][1] += 1.0; L[0] = ' '; } do { p1 = strstr ( L,"+Y" ); if (p1) { T[n][1] += 1.0; strncpy ( p1," ",2 ); } } while (p1); do { p1 = strstr ( L,"-Y" ); if (p1) { T[n][1] -= 1.0; strncpy ( p1," ",2 ); } } while (p1); T[n][2] = 0.0; if (L[0]=='Z') { T[n][2] += 1.0; L[0] = ' '; } do { p1 = strstr ( L,"+Z" ); if (p1) { T[n][2] += 1.0; strncpy ( p1," ",2 ); } } while (p1); do { p1 = strstr ( L,"-Z" ); if (p1) { T[n][2] -= 1.0; strncpy ( p1," ",2 ); } } while (p1); DelSpaces ( L ); if ((int)strlen(L)>=len) return SYMOP_NotAnOperation; // translational part p1 = L; T[n][3] = strtod ( p1,&p2 ); if (*p2=='/') { p1 = p2+1; V = strtod ( p1,&p2 ); if (V==0.0) return SYMOP_ZeroDenominator; T[n][3] /= V; } return SYMOP_Ok; } void MakeSign ( pstr S, realtype V, realtype & AV ) { int l; if (V>0.0) { l = strlen ( S ); if (l>0) { if (S[l-1]!=',') { strcat ( S,"+" ); } } AV = V; } else if (V<0.0) { strcat ( S,"-" ); AV = -V; } else { AV = V; return; } } #define __eps 1.0e-5 void GenTranslation ( pstr S, realtype V ) { realtype AV,nAV; char N[50]; int n,d; if (fabs(V)<=__eps) return; MakeSign ( S,V,AV ); d = 0; n = -1; while ((d<=20) && (n<0)) { d++; nAV = AV*d; n = mround(nAV); if (fabs(nAV-n)>__eps) n = -1; } if (d<=1) sprintf ( N,"%i" ,n ); else if (n>=0) sprintf ( N,"%i/%i" ,n,d ); else sprintf ( N,"%-.10g",AV ); strcat ( S,N ); } void GenTransformation ( pstr S, realtype V, pstr Axis ) { realtype AV,nAV; char N[50]; int n,d; if (fabs(V)<=__eps) return; MakeSign ( S,V,AV ); if (fabs(AV-1.0)>__eps) { d = 0; n = -1; while ((d<=20) && (n<0)) { d++; nAV = AV*d; n = mround(nAV); if (fabs(nAV-n)>__eps) n = -1; } if (n>=0) sprintf ( N,"%i/%i*",n,d ); else sprintf ( N,"%-.10g*",AV ); strcat ( S,N ); } strcat ( S,Axis ); } /* void GenTranslation ( pstr S, realtype V ) { realtype AV,fAV; int n,d; char N[50]; if (V==0.0) return; MakeSign ( S,V,AV ); n = mround(floor(AV+0.00000001)); fAV = AV-n; if (fabs(fAV-0.5)<=__eps) { n += 1; d = 2; } else if (fabs(fAV-0.25)<=__eps) { n += 1; d = 4; } else if (fabs(fAV-0.75)<=__eps) { n += 3; d = 4; } else if (fabs(fAV-0.33333333333)<=__eps) { n += 1; d = 3; } else if (fabs(fAV-0.66666666666)<=__eps) { n += 2; d = 3; } else if (fabs(fAV-0.16666666666)<=__eps) { n += 1; d = 6; } else if (fabs(fAV-0.83333333333)<=__eps) { n += 5; d = 6; } else d = 1; N[0] = char(0); if (d>1) sprintf ( N,"%i/%i",n,d ); else if (n>0) sprintf ( N,"%i",n ); else ParamStr ( N,pstr(""),AV ); strcat ( S,N ); } void GenTransformation ( pstr S, realtype V, pstr Axis ) { realtype AV; if (V==0.0) return; MakeSign ( S,V,AV ); if (fabs(AV-0.5)<=__eps) strcat ( S,"1/2*" ); else if (fabs(AV-0.25)<=__eps) strcat ( S,"1/4*" ); else if (fabs(AV-0.75)<=__eps) strcat ( S,"3/4*" ); else if (fabs(AV-0.33333333333)<=__eps) strcat ( S,"1/3*" ); else if (fabs(AV-0.66666666666)<=__eps) strcat ( S,"2/3*" ); else if (fabs(AV-0.16666666666)<=__eps) strcat ( S,"1/6*" ); else if (fabs(AV-0.83333333333)<=__eps) strcat ( S,"5/6*" ); else if (fabs(AV-1.0)>__eps) ParamStr ( S,pstr(""),AV, 10,pstr("*") ); strcat ( S,Axis ); } */ Boolean CSymOp::CompileOpTitle ( pstr S ) { return CompileOpTitle ( S,T,True ); } Boolean CSymOp::CompileOpTitle ( pstr S, mat44 symMat, Boolean compare ) { S[0] = char(0); GenTransformation ( S,symMat[0][0],pstr("X") ); GenTransformation ( S,symMat[0][1],pstr("Y") ); GenTransformation ( S,symMat[0][2],pstr("Z") ); GenTranslation ( S,symMat[0][3] ); strcat ( S,"," ); GenTransformation ( S,symMat[1][0],pstr("X") ); GenTransformation ( S,symMat[1][1],pstr("Y") ); GenTransformation ( S,symMat[1][2],pstr("Z") ); GenTranslation ( S,symMat[1][3] ); strcat ( S,"," ); GenTransformation ( S,symMat[2][0],pstr("X") ); GenTransformation ( S,symMat[2][1],pstr("Y") ); GenTransformation ( S,symMat[2][2],pstr("Z") ); GenTranslation ( S,symMat[2][3] ); DelSpaces ( S ); if ((!compare) || (!strcmp(S,XYZOp))) return True; else { S[0] = char(0); GenTranslation ( S,symMat[0][3] ); GenTransformation ( S,symMat[0][0],pstr("X") ); GenTransformation ( S,symMat[0][1],pstr("Y") ); GenTransformation ( S,symMat[0][2],pstr("Z") ); strcat ( S,"," ); GenTranslation ( S,symMat[1][3] ); GenTransformation ( S,symMat[1][0],pstr("X") ); GenTransformation ( S,symMat[1][1],pstr("Y") ); GenTransformation ( S,symMat[1][2],pstr("Z") ); strcat ( S,"," ); GenTranslation ( S,symMat[2][3] ); GenTransformation ( S,symMat[2][0],pstr("X") ); GenTransformation ( S,symMat[2][1],pstr("Y") ); GenTransformation ( S,symMat[2][2],pstr("Z") ); DelSpaces ( S ); if (!strcmp(S,XYZOp)) return True; } return False; } void CSymOp::Transform ( realtype & x, realtype & y, realtype & z ) { realtype x1,y1,z1; x1 = T[0][0]*x + T[0][1]*y + T[0][2]*z + T[0][3]; y1 = T[1][0]*x + T[1][1]*y + T[1][2]*z + T[1][3]; z1 = T[2][0]*x + T[2][1]*y + T[2][2]*z + T[2][3]; x = x1; y = y1; z = z1; } void CSymOp::GetTMatrix ( mat44 & TMatrix ) { // copies T to TMatrix int i,j; for (i=0;i<4;i++) for (j=0;j<4;j++) TMatrix[i][j] = T[i][j]; } void CSymOp::SetTMatrix ( mat44 & TMatrix ) { // copies TMatrix to T int i,j; for (i=0;i<4;i++) for (j=0;j<4;j++) T[i][j] = TMatrix[i][j]; } void CSymOp::Print() { int i; printf ( " operation '%s'\n",XYZOp ); for (i=0;i<4;i++) printf ( " %10.3g %10.3g %10.3g %10.3g\n", T[i][0],T[i][1],T[i][2],T[i][3] ); } void CSymOp::Copy ( PCSymOp SymOp ) { int i,j; CreateCopy ( XYZOp,SymOp->XYZOp ); for (i=0;i<4;i++) for (j=0;j<4;j++) T[i][j] = SymOp->T[i][j]; } void CSymOp::write ( RCFile f ) { int i,j; byte Version=1; f.WriteByte ( &Version ); f.CreateWrite ( XYZOp ); for (i=0;i<4;i++) for (j=0;j<4;j++) f.WriteReal ( &(T[i][j]) ); } void CSymOp::read ( RCFile f ) { int i,j; byte Version; f.ReadByte ( &Version ); f.CreateRead ( XYZOp ); for (i=0;i<4;i++) for (j=0;j<4;j++) f.ReadReal ( &(T[i][j]) ); } MakeStreamFunctions(CSymOp); // ==================== CSymOps ======================== CSymOps::CSymOps() : CStream() { InitSymOps(); } CSymOps::CSymOps ( RPCStream Object ) : CStream(Object) { InitSymOps(); } CSymOps::~CSymOps() { FreeMemory(); } void CSymOps::InitSymOps() { SpGroup = NULL; Nops = 0; SymOp = NULL; } void CSymOps::FreeMemory() { int i; if (SpGroup) delete[] SpGroup; SpGroup = NULL; if (SymOp) { for (i=0;iSetSymOp ( S ); } f.shut(); return RC; } #define syminfo_file cpstr("syminfo.lib") int CSymOps::SetGroup ( cpstr SpaceGroup, cpstr syminfo_lib ) { CFile f; pstr p; psvector lines,lines1; char S[500]; char G[100]; char O[100]; mat44 T1,T2,T3; int i,j,k,l,m,n,RC; int nlines,npops,ncops; FreeMemory(); npops = 0; ncops = 0; CreateCopy ( SpGroup,SpaceGroup ); if (!syminfo_lib) p = pstr(syminfo_file); else if (!syminfo_lib[0]) p = pstr(syminfo_file); else p = pstr(syminfo_lib); f.assign ( p,True ); if (!f.reset(True)) { p = getenv ( "SYMINFO" ); if (p) strcpy ( S,p ); else { p = getenv ( "CLIBD" ); if (p) { strcpy ( S,p ); if (S[strlen(S)-1]!='/') strcat ( S,"/" ); strcat ( S,"syminfo.lib" ); } else strcpy ( S,"syminfo.lib" ); } f.assign ( S,True ); if (!f.reset(True)) return SYMOP_NoLibFile; } if (strncasecmp(SpGroup,"Hall:",5)) { // normal space group symbol on input strcpy ( G," '" ); strcat ( G,SpGroup ); strcat ( G,"'" ); S[0] = char(0); while (!f.FileEnd() && !(strstr(S,G) && (strstr(S,"symbol xHM") || strstr(S,"symbol old")))) f.ReadLine ( S,sizeof(S) ); } else { // hall descriptor on input strcpy ( G," ' " ); p = &(SpGroup[5]); while (*p==' ') p++; strcat ( G,p ); strcat ( G,"'" ); S[0] = char(0); while (!f.FileEnd() && !(strstr(S,G) && strstr(S,"symbol Hall"))) f.ReadLine ( S,sizeof(S) ); } if (f.FileEnd()) { f.shut(); return SYMOP_UnknownSpaceGroup; } // found spacegroup, move to symop lines while (!f.FileEnd() && (!strstr(S,"symop"))) f.ReadLine ( S,sizeof(S) ); nlines = 256; GetVectorMemory ( lines,nlines,0 ); for (i=0;i=nlines) { nlines += + 256; GetVectorMemory ( lines1,nlines,0 ); for (i=0;i=nlines) { nlines += + 256; GetVectorMemory ( lines1,nlines,0 ); for (i=0;iSetSymOp ( lines[n++]+6 ); } // loop over non-trivial centering operators, and for each loop // over primtive operators for (i=1;(iSetSymOp ( lines[n]+6 ); SymOp[i*npops+j]->GetTMatrix(T1); SymOp[j]->GetTMatrix(T2); for (k=0;k<4;k++) for (l=0;l<4;l++) { T3[k][l] = 0.0; for (m=0;m<4;m++) T3[k][l] += T1[k][m]*T2[m][l]; } for (k=0;k<3;k++) // kdc fix T3[k][3] -= floor ( T3[k][3] ); // kdc fix SymOp[i*npops+j]->CompileOpTitle ( O,T3,False ); SymOp[i*npops+j]->SetSymOp ( O ); } } f.shut(); for (i=0;iSetSymOp ( S+6 ); } // skip identity centering operator f.ReadLine ( S,sizeof(S) ); // loop over non-trivial centering operators, and for each loop // over primtive operators for (i=1;(iSetSymOp ( S+6 ); SymOp[i*npops+j]->GetTMatrix(T1); SymOp[j]->GetTMatrix(T2); for (k=0;k<4;k++) for (l=0;l<4;l++) { T3[k][l] = 0.0; for (m=0;m<4;m++) T3[k][l] += T1[k][m]*T2[m][l]; } for (k=0;k<3;k++) // kdc fix T3[k][3] -= floor ( T3[k][3] ); // kdc fix SymOp[i*npops+j]->CompileOpTitle(O,T3,False); SymOp[i*npops+j]->SetSymOp (O); } } f.shut(); return RC; } */ void CSymOps::Reset() { // removes all symmetry operations FreeMemory(); } int CSymOps::AddSymOp ( cpstr XYZOperation ) { // adds a symmetry operation PPCSymOp SymOp1; int i; SymOp1 = new PCSymOp[Nops+1]; for (i=0;iSetSymOp ( XYZOperation ); } void CSymOps::PutGroupName ( cpstr SpGroupName ) { CreateCopy ( SpGroup,SpGroupName ); } int CSymOps::GetNofSymOps() { // GetNofSymOps() returns Nops -- the number of symmetry operations return Nops; } pstr CSymOps::GetSymOp ( int Nop ) { if ((0<=Nop) && (NopGetSymOp(); else return pstr(""); } int CSymOps::Transform ( realtype & x, realtype & y, realtype & z, int Nop ) { // Transform(..) transforms the coordinates according to the // symmetry operation Nop. The return code is non-zero if // Nop is a wrong operation number (must range from 0 to Nops-1). if ((Nop<0) || (Nop>=Nops)) return 1; if (SymOp[Nop]) { SymOp[Nop]->Transform ( x,y,z ); return 0; } else return 2; } int CSymOps::GetTMatrix ( mat44 & TMatrix, int Nop ) { // GetTMatrix(..) returns the coordinate transformation matrix // for the symmetry operation Nop. The return code is non-zero if // Nop is a wrong operation number (must range from 0 to Nops-1). if ((Nop<0) || (Nop>=Nops)) return 1; if (SymOp[Nop]) { SymOp[Nop]->GetTMatrix ( TMatrix ); return 0; } else return 2; } void CSymOps::Print() { int i; char S[200]; printf ( " SPACE GROUP '%s'\n",SpGroup ); for (i=0;iPrint(); if (SymOp[i]->CompileOpTitle(S)) printf ( " CHECK STATUS: Ok\n" ); else printf ( " CHECK STATUS: Generated '%s'\n",S ); } } void CSymOps::Copy ( PCSymOps SymOps ) { int i; FreeMemory(); CreateCopy ( SpGroup,SymOps->SpGroup ); Nops = SymOps->Nops; if (Nops>0) { SymOp = new PCSymOp[Nops]; for (i=0;iCopy ( SymOps->SymOp[i] ); } } } void CSymOps::write ( RCFile f ) { int i; byte Version=1; f.WriteByte ( &Version ); f.CreateWrite ( SpGroup ); f.WriteInt ( &Nops ); for (i=0;i0) { SymOp = new PCSymOp[Nops]; for (i=0;i // ~~~~~~~~~ // **** Project : MacroMolecular Data Base (MMDB) // ~~~~~~~~~ // **** Classes : CMMDBManager ( MMDB file manager class ) // ~~~~~~~~~ // // (C) E. Krissinel 2000-2013 // // ================================================================= // #ifndef __STRING_H #include #endif #ifndef __MMDB_Manager__ #include "mmdb_manager.h" #endif // ===================== CMMDBManager ======================= CMMDBManager::CMMDBManager() : CMMDBBondManager() { } CMMDBManager::CMMDBManager ( RPCStream Object ) : CMMDBBondManager(Object) { } CMMDBManager::~CMMDBManager() {} void CMMDBManager::Copy ( PCMMDBManager MMDB, word CopyMask ) { PCModel model; PPCChain chain; PCChain ch; ChainID chID; int i,j, nchains; if (CopyMask & MMDBFCM_Flags) Flags = MMDB->Flags; if (CopyMask & MMDBFCM_Title) Title.Copy ( &(MMDB->Title) ); if (CopyMask & MMDBFCM_Cryst) Cryst.Copy ( &(MMDB->Cryst) ); if (CopyMask & MMDBFCM_Coord) { FreeCoordMemory (); DeleteAllSelections(); nAtoms = MMDB->nAtoms; AtmLen = nAtoms; if (nAtoms>0) { Atom = new PCAtom[AtmLen]; for (i=0;iAtom[i]) { Atom[i] = newCAtom(); Atom[i]->Copy ( MMDB->Atom[i] ); // the internal atom references are installed // by residue classes when they are read in // model->chain below Atom[i]->SetAtomIndex ( i+1 ); } else Atom[i] = NULL; } } nModels = MMDB->nModels; if (nModels>0) { Model = new PCModel[nModels]; for (i=0;iModel[i]) { Model[i] = newCModel(); Model[i]->SetMMDBManager ( this,0 ); Model[i]->_copy ( MMDB->Model[i] ); } else Model[i] = NULL; } } crModel = NULL; crChain = NULL; crRes = NULL; if (MMDB->crModel) { for (i=0;iserNum==MMDB->crModel->serNum) { crModel = Model[i]; break; } } if (crModel && crModel->Chain && MMDB->crChain) for (i=0;inChains;i++) if (crModel->Chain[i]) { if (!strcmp(crModel->Chain[i]->chainID, MMDB->crModel->Chain[i]->chainID)) { crChain = crModel->Chain[i]; break; } } if (crChain && crChain->Residue && MMDB->crRes) for (i=0;inResidues;i++) if (crChain->Residue[i]) { if ((!strcmp(crChain->Residue[i]->name, MMDB->crRes->name)) && (crChain->Residue[i]->seqNum==MMDB->crRes->seqNum) && (!strcmp(crChain->Residue[i]->insCode, MMDB->crRes->insCode))) { crRes = crChain->Residue[i]; break; } } } /* if ((MMDB->nSelections>0) && MMDB->Mask) { nSelections = MMDB->nSelections; if (nSelections>0) { Mask = new PCMask [nSelections]; SelAtom = new PPCAtom[nSelections]; nSelAtoms = new int [nSelections]; for (i=0;iCopyMask ( MMDB->Mask[i] ); nSelAtoms[i] = MMDB->nSelAtoms[i]; if (nSelAtoms[i]>0) { SelAtom[i] = new PCAtom[nSelAtoms[i]]; for (j=0;jSelAtom[i][j]->index]; } else SelAtom[i] = NULL; } } } */ } else if (CopyMask & (MMDBFCM_HetInfo | MMDBFCM_SecStruct | MMDBFCM_Links | MMDBFCM_CisPeps | MMDBFCM_ChainAnnot)) { for (i=0;inModels;i++) if (MMDB->Model[i]) { model = GetModel ( i+1 ); if (!model) { model = new CModel( NULL,i+1 ); AddModel ( model ); } if (CopyMask & MMDBFCM_HetInfo) model->CopyHets ( MMDB->Model[i] ); if (CopyMask & MMDBFCM_SecStruct) model->CopySecStructure ( MMDB->Model[i] ); if (CopyMask & MMDBFCM_Links) { model->CopyLinks ( MMDB->Model[i] ); model->CopyLinkRs ( MMDB->Model[i] ); } if (CopyMask & MMDBFCM_CisPeps) model->CopyCisPeps ( MMDB->Model[i] ); if (CopyMask & MMDBFCM_ChainAnnot) { MMDB->GetChainTable ( i+1,chain,nchains ); for (j=0;jGetChainID ( chID ); ch = model->GetChain ( chID ); if (!ch) { ch = new CChain(); ch->SetChainID ( chID ); model->AddChain ( ch ); } ch->CopyAnnotations ( chain[j] ); } } } } if (CopyMask & MMDBFCM_SA) SA.Copy ( &(MMDB->SA) ); if (CopyMask & MMDBFCM_SB) SB.Copy ( &(MMDB->SB) ); if (CopyMask & MMDBFCM_SC) SC.Copy ( &(MMDB->SC) ); if (CopyMask & MMDBFCM_Footnotes) Footnote.Copy ( &(MMDB->Footnote) ); if (CopyMask & MMDBFCM_Buffer) { lcount = MMDB->lcount; strncpy ( S,MMDB->S,sizeof(S) ); } } void CMMDBManager::Delete ( word DelMask ) { PPCModel model; PPCChain chain; int i,j,nm, nchains; if (DelMask & MMDBFCM_Flags) Flags = 0; if (DelMask & MMDBFCM_Title) Title.Copy ( NULL ); if (DelMask & MMDBFCM_TitleKeepBM) Title.FreeMemory ( True ); if (DelMask & MMDBFCM_Cryst) Cryst.Copy ( NULL ); if (DelMask & MMDBFCM_Coord) { FreeCoordMemory (); DeleteAllSelections(); } if (DelMask & MMDBFCM_SecStruct) { GetModelTable ( model,nm ); if (model) for (i=0;iRemoveSecStructure(); } if (DelMask & MMDBFCM_HetInfo) { GetModelTable ( model,nm ); if (model) for (i=0;iRemoveHetInfo(); } if (DelMask & MMDBFCM_Links) { GetModelTable ( model,nm ); if (model) for (i=0;iRemoveLinks (); model[i]->RemoveLinkRs(); } } if (DelMask & MMDBFCM_CisPeps) { GetModelTable ( model,nm ); if (model) for (i=0;iRemoveCisPeps(); } if (DelMask & MMDBFCM_ChainAnnot) { nm = GetNumberOfModels(); for (i=1;i<=nm;i++) { GetChainTable ( i,chain,nchains ); if (chain) for (j=0;jFreeAnnotations(); } } if (DelMask & MMDBFCM_SA) SA.FreeContainer(); if (DelMask & MMDBFCM_SB) SB.FreeContainer(); if (DelMask & MMDBFCM_SC) SC.FreeContainer(); if (DelMask & MMDBFCM_Footnotes) Footnote.FreeContainer(); if (DelMask & MMDBFCM_Buffer) { lcount = 0; S[0] = char(0); } } PCTitleContainer CMMDBManager::GetRemarks() { return Title.GetRemarks(); } PCTitleContainer CMMDBManager::GetJournal() { return Title.GetJournal(); } realtype CMMDBManager::GetResolution() { return Title.GetResolution(); } int CMMDBManager::ParseBiomolecules() { return Title.ParseBiomolecules(); } int CMMDBManager::GetNofBiomolecules() { return Title.GetNofBiomolecules(); } void CMMDBManager::GetBiomolecules ( PPCBiomolecule & BM, int & nBMs ) { Title.GetBiomolecules ( BM,nBMs ); } PCBiomolecule CMMDBManager::GetBiomolecule ( int bmNo ) { return Title.GetBiomolecule ( bmNo ); } PCMMDBManager CMMDBManager::MakeBiomolecule ( int bmNo, int modelNo ) { PCMMDBManager M; PPCChain ch; PCChain chain; PCModel model; PCBiomolecule BM; int i,j,k,n,n0,nChains; BM = Title.GetBiomolecule ( bmNo ); if (!BM) return NULL; GetChainTable ( modelNo,ch,nChains ); if ((!ch) || (nChains<=0)) return NULL; n0 = 0; model = new CModel(); for (i=0;(inBMAs) && (n0>=0);i++) if (BM->BMApply[i]) { for (j=0;(jBMApply[i]->nMatrices) && (n0>=0);j++) for (k=0;(kBMApply[i]->nChains) && (n0>=0);k++) { n0 = -1; for (n=0;(nGetChainID(),BM->BMApply[i]->chain[k])) n0 = n; if (n0>=0) { chain = new CChain(); chain->Copy ( ch[n0] ); chain->ApplyTransform ( BM->BMApply[i]->tm[j] ); model->AddChain ( chain ); } } } if (n0>=0) { M = new CMMDBManager(); M->AddModel ( model ); M->PDBCleanup ( PDBCLEAN_SERIAL | PDBCLEAN_INDEX ); } else { delete model; M = NULL; } return M; } // ------------------- Stream functions ---------------------- void CMMDBManager::write ( RCFile f ) { byte Version=1; f.WriteByte ( &Version ); CMMDBBondManager::write ( f ); } void CMMDBManager::read ( RCFile f ) { byte Version; f.ReadByte ( &Version ); CMMDBBondManager::read ( f ); } MakeStreamFunctions(CMMDBManager) mmdb-1.25.5/mmdb/mmdb_bondmngr.cpp0000775000175000017500000000673011736610510013707 00000000000000// $Id: mmdb_bondmngr.cpp,v 1.21 2012/01/26 17:52:20 ekr Exp $ // ================================================================= // // CCP4 Coordinate Library: support of coordinate-related // functionality in protein crystallography applications. // // Copyright (C) Eugene Krissinel 2000-2008. // // This library is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // // ================================================================= // // 29.01.10 <-- Date of Last Modification. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ----------------------------------------------------------------- // // **** Module : mmdb_bondmngr // ~~~~~~~~~ // **** Project : MacroMolecular Data Base (MMDB) // ~~~~~~~~~ // **** Classes : CMMDBBondManager ( MMDB bonds maker ) // ~~~~~~~~~ // // (C) E. Krissinel 2000-2010 // // ================================================================= // #ifndef __STRING_H #include #endif #ifndef __MMDB_BondMngr__ #include "mmdb_bondmngr.h" #endif #ifndef __MMDB_Graph__ #include "mmdb_graph.h" #endif // ===================== CMMDBBondManager ===================== CMMDBBondManager::CMMDBBondManager() : CMMDBSelManager() { } CMMDBBondManager::CMMDBBondManager ( RPCStream Object ) : CMMDBSelManager(Object) { } CMMDBBondManager::~CMMDBBondManager() {} void CMMDBBondManager::MakeBonds ( Boolean calc_only ) { UNUSED_ARGUMENT(calc_only); PCModel model; PCChain chain; PCResidue res; CGraph graph; PPCVertex V; PPCEdge E; int i, im,ic,ir, nV,nE, k1,k2; RemoveBonds(); for (im=0;imnChains;ic++) { chain = model->Chain[ic]; if (chain) for (ir=0;irnResidues;ir++) { res = chain->Residue[ir]; if (res) { graph.MakeGraph ( res,NULL ); graph.GetVertices ( V,nV ); graph.GetEdges ( E,nE ); for (i=0;iGetVertex1()]->GetUserID(); k2 = V[E[i]->GetVertex2()]->GetUserID(); res->atom[k1]->AddBond ( res->atom[k2],E[i]->GetType() ); res->atom[k2]->AddBond ( res->atom[k1],E[i]->GetType() ); } } } } } } void CMMDBBondManager::RemoveBonds() { int i; for (i=0;iFreeBonds(); } // ------------------- Stream functions ---------------------- void CMMDBBondManager::write ( RCFile f ) { byte Version=1; f.WriteByte ( &Version ); CMMDBSelManager::write ( f ); } void CMMDBBondManager::read ( RCFile f ) { byte Version; f.ReadByte ( &Version ); CMMDBSelManager::read ( f ); } MakeStreamFunctions(CMMDBBondManager) mmdb-1.25.5/mmdb/bfgs_min.cpp0000775000175000017500000005477111736610510012676 00000000000000// $Id: bfgs_min.cpp,v 1.19 2012/01/26 17:52:19 ekr Exp $ // ================================================================= // // CCP4 Coordinate Library: support of coordinate-related // functionality in protein crystallography applications. // // Copyright (C) Eugene Krissinel 2000-2008. // // This library is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // ================================================================= // // 27.06.01 <-- Date of Last Modification. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ----------------------------------------------------------------- // // **** Module : bfgs_min // ~~~~~~~~~ // **** Classes : CBFGSMin ( minimization driver ) // ~~~~~~~~~ // // (C) E. Krissinel 2000-2008 // // ================================================================= // #ifndef __MATH_H #include #endif #ifndef __BFGS_Min__ #include "bfgs_min.h" #endif // ============================================================== CBFGSMin::CBFGSMin() { MFunc = NULL; MFuncData = NULL; PFunc = NULL; PFuncData = NULL; N = 0; NAlloc = 0; Hsn = NULL; TL = NULL; LL = NULL; XOpt = NULL; XPlus = NULL; Sx = NULL; SN = NULL; HDiag = NULL; GradX = NULL; GPlus = NULL; StepSize = NULL; FNeighbor = NULL; us = NULL; uy = NULL; ut = NULL; Freese = NULL; Func = 0.0; FPlus = 0.0; FOpt = 0.0; TakenLambda = 0.0; ForDiff = False; CalcHess = False; Etha = 0.0; SqrtEtha = 0.0; CubertEtha = 0.0; TpF = 1.0; GrdEps = 0.0; StpEps = 0.0; MxStep = MaxReal; CnsMax = 0; MaxItn = 100; TermCode = BFGS_NoTermination; ModF = False; } CBFGSMin::~CBFGSMin() { FreeMemory(); } void CBFGSMin::MinFunc ( rvector X, realtype & F ) { if (MFunc) (*MFunc)(MFuncData,N,X,F); else F = 0.0; } void CBFGSMin::MinFunc1 ( rvector X, realtype & F ) { int i; MinFunc ( X,F ); if (ModF && (FEtha) Etha = MachEps; } SqrtEtha = sqrt(Etha); CubertEtha = Exp ( log(Etha)/3.0 ); if (Etha>0.01) { TermCode = BFGS_TooFewDigits; return; } if (TypF<=0.0) TpF = 1.0; else TpF = TypF; S1 = Exp(log(MachEps)/3.0); if (GrdTol>0.0) GrdEps = GrdTol; else { GrdEps = sqrt(Etha); if (S1>GrdEps) GrdEps = S1; } if (StpTol>0.0) StpEps = StpTol; else StpEps = Exp ( log(MachEps)*2.0/3.0 ); if (MaxStp>0.0) MxStep = MaxStp; else { S1 = 0.0; S2 = 0.0; for (i=1;i<=N;i++) { S0 = Sx[i]; S0 *= Sx[i]; S2 += S0; S0 *= x0[i]; S1 += S0*x0[i]; } S1 = sqrt(S1); S2 = sqrt(S2); if (S2>S1) MxStep = S2; else MxStep = S1; MxStep *= 1000.0; } if (ItnLmt>0) MaxItn = ItnLmt; else MaxItn = 100; TermCode = BFGS_NoTermination; } // ------------------------------------------------------------------- void CBFGSMin::UMStop0 ( rvector x0, rvector Grad ) { int i; realtype S,Fmax,St; CnsMax = 0; if (TpF>fabs(Func)) Fmax = TpF; else Fmax = fabs(Func); S = 0.0; for (i=1;i<=N;i++) { St = fabs(x0[i]); if (1.0/Sx[i]>St) St = 1.0/Sx[i]; St = fabs(Grad[i])*St/Fmax; if (St>S) S = St; } if (S>=0.001*GrdEps) TermCode = BFGS_NoTermination; else TermCode = BFGS_SmallGradient; } // ------------------------------------------------------------------- void CBFGSMin::UMStop ( rvector x0, rvector Grad, int RetCode, int ItnCnt, Boolean MaxTkn ) { // A7.2.1 : Checking the Stop Conditions int i; realtype Max1,Max2,MaxGrad,MaxStep, BB1,BB2; TermCode = BFGS_NoTermination; if (RetCode==1) TermCode = BFGS_LineSearchComplete; else { if (fabs(FPlus)>TpF) Max2 = fabs(FPlus); else Max2 = TpF; MaxGrad = 0.0; MaxStep = 0.0; for (i=1;i<=N;i++) { BB1 = fabs(XPlus[i]); BB2 = 1.0/Sx[i]; if (BB1>BB2) Max1 = BB1; else Max1 = BB2; BB1 = fabs(Grad[i])*Max1/Max2; if (BB1>MaxGrad) MaxGrad = BB1; BB2 = fabs(XPlus[i]-x0[i])/Max1; if (BB2>MaxStep) MaxStep = BB2; } if (MaxGradMaxItn) TermCode = BFGS_IterationLimit; else if (MaxTkn) { CnsMax++; if (CnsMax==5) TermCode = BFGS_LargeSteps; } else CnsMax = 0; } } // ------------------------------------------------------------------- void CBFGSMin::MdHess ( rmatrix H, rvector HDg ) { // A5.5.1 : Setting up the hessian of model int i,j; realtype MaxDiag,MaxOff, MinEv,Mue,MaxPosDiag; realtype MaxOffl,MinDiag,MaxEv,MaxAdd,Sdd,OffRow; realtype BB; // Scaling for (i=1;i<=N;i++) for (j=i;j<=N;j++) H[i][j] /= (Sx[i]*Sx[j]); MaxDiag = H[1][1]; MinDiag = H[1][1]; MaxOff = 0.0; for (i=1;i<=N;i++) { if (H[i][i]>MaxDiag) MaxDiag = H[i][i]; if (H[i][i]MaxOff) MaxOff = BB; } } MaxPosDiag = 0.0; if (MaxDiag>MaxPosDiag) MaxPosDiag = MaxDiag; // Computing the shift of the spectra (the Mue) if (MinDiag>SqrtEps*MaxPosDiag) Mue = 0.0; else { Mue = 2.0*(MaxPosDiag-MinDiag)*SqrtEps-MinDiag; MaxDiag += Mue; } BB = MaxOff*(1.0+2.0*SqrtEps); if (BB>MaxDiag) { Mue = Mue+(MaxOff-MaxDiag)+2.0*SqrtEps*MaxOff; MaxDiag = BB; } if (MaxDiag==0.0) { // H = 0 Mue = 1.0; MaxDiag = 1.0; } if (Mue>0.0) for (i=1;i<=N;i++) Hsn[i][i] += Mue; MaxOffl = MaxOff/N; if (MaxDiag>MaxOffl) MaxOffl = MaxDiag; MaxOffl = sqrt(MaxOffl); for (i=1;i<=N;i++) HDg[i] = H[i][i]; PbCholDecomp ( N,HDg,MaxOffl,MachEps,H,MaxAdd ); if (MaxAdd>0.0) { MaxEv = HDg[1]; MinEv = HDg[1]; for (i=1;i<=N;i++) { OffRow = 0.0; if (i>1) for (j=1;jMaxEv) MaxEv = BB; BB = HDg[i]-OffRow; if (BBBB2) StepSizeJ = BB1; else StepSizeJ = BB2; if (X[j]<0.0) StepSizeJ = -StepSizeJ; StepSizeJ *= SqrtEtha; TempJ = X[j]; X[j] += StepSizeJ; StepSizeJ = X[j]-TempJ; MinFunc1 ( X,Fj ); if (TermCode!=BFGS_NoTermination) return; G[j] = (Fj-Fc)/StepSizeJ; X[j] = TempJ; Freese[j] = False; if (TL) { if ((fabs(X[j]-TL[j])<=StepSizeJ) && (G[j]<0.0)) { G[j] = 0.0; Freese[j] = True; } } if (LL) { if ((fabs(X[j]-LL[j])<=StepSizeJ) && (G[j]>0.0)) { G[j] = 0.0; Freese[j] = True; } } } } // ------------------------------------------------------------------- void CBFGSMin::CDGrad ( rvector X, rvector G ) { // A5.6.4 : Central Differencies Approximation of // Gradient realtype StepSizeJ,TempJ,Fp,Fm, BB1,BB2; int j; for (j=1;j<=N;j++) { BB1 = fabs(X[j]); BB2 = 1.0/Sx[j]; if (BB1>BB2) StepSizeJ = BB1; else StepSizeJ = BB2; if (X[j]<0.0) StepSizeJ = -StepSizeJ; StepSizeJ *= CubertEtha; TempJ = X[j]; X[j] += StepSizeJ; StepSizeJ = X[j]-TempJ; MinFunc1 ( X,Fp ); if (TermCode!=BFGS_NoTermination) return; X[j] = TempJ-StepSizeJ; MinFunc1 ( X,Fm ); if (TermCode!=BFGS_NoTermination) return; G[j] = (Fp-Fm)/(2.0*StepSizeJ); X[j] = TempJ; } } // ------------------------------------------------------------------- void CBFGSMin::Gradient ( rvector X, rvector G, realtype Fc ) { if (ForDiff) FDGrad ( X,G,Fc ); else CDGrad ( X,G ); } // ------------------------------------------------------------------- void CBFGSMin::FDHessF ( realtype Fc, rvector X ) { // A5.6.2 : Finite-Difference Approximation of // the Hessian employing only the // function's values int i,j; realtype S,TempI,Fii,TempJ,Fij, BB1,BB2; for (i=1;i<=N;i++) if (!Freese[i]) { BB1 = fabs(X[i]); BB2 = 1.0/Sx[i]; if (BB1>BB2) S = BB1; else S = BB2; if (X[i]<0.0) S = -S; StepSize[i] = S*CubertEtha; TempI = X[i]; X[i] += StepSize[i]; StepSize[i] = X[i]-TempI; MinFunc1 ( X,FNeighbor[i] ); X[i] = TempI; if (TermCode!=BFGS_NoTermination) return; } for (i=1;i<=N;i++) if (!Freese[i]) { TempI = X[i]; X[i] += 2.0*StepSize[i]; MinFunc1 ( X,Fii ); if (TermCode!=BFGS_NoTermination) return; Hsn[i][i] = (( Fc -FNeighbor[i] ) + ( Fii-FNeighbor[i] )) / (StepSize[i]*StepSize[i]); X[i] = TempI+StepSize[i]; if (iTemp) Temp = TpF; for (i=1;i<=N;i++) { H[i][i] = Temp*Sx[i]*Sx[i]; if (isqrt(MachEps*NormS*NormY)) { if (AnalGrad) Tol = Etha; else Tol = sqrt(Etha); SkipUpdate = True; for (i=1;i<=N;i++) { tt = 0.0; for (j=1;j<=i;j++) tt += H[j][i]*us[j]; if (itt) tt = BB; if (fabs(uy[i]-ut[i])>=Tol*tt) SkipUpdate = False; } if (!SkipUpdate) { Temp2 = 0.0; for (i=1;i<=N;i++) Temp2 += us[i]*ut[i]; for (i=1;i<=N;i++) for (j=i;j<=N;j++) H[i][j] += uy[i]*uy[j]/Temp1 - ut[i]*ut[j]/Temp2; } } } // ------------------------------------------------------------------- void CBFGSMin::Choose_Lambda ( rvector X, rvector S, realtype & Lambda0 ) { int i; realtype SS; for (i=1;i<=N;i++) if ((S[i]!=0.0) && (!Freese[i])) { SS = X[i] + Lambda0*S[i]; if (TL) { if (SS>TL[i]) Lambda0 = (TL[i]-X[i])/S[i]/(1.0+MachEps); } if (LL) { if (SSMxStep) { // restrict Newtonian step to MxStep S = MxStep/NewtLn; for (i=1;i<=N;i++) P[i] *= S; NewtLn = MxStep; } InitSp = 0.0; RelLng = 0.0; Lambda0 = 1.0; Choose_Lambda ( px0,P,Lambda0 ); for (i=1;i<=N;i++) { InitSp += G[i]*P[i]; B1 = fabs(px0[i]); B2 = 1.0/Sx[i]; if (B1>B2) S = B1; else S = B2; S = fabs(P[i])/S; if (S>RelLng) RelLng = S; } InitSp *= Lambda0; MinLam = StpEps/RelLng; Lambda = Lambda0; do { for (i=1;i<=N;i++) XPlus[i] = px0[i] + Lambda*P[i]; MinFunc1 ( XPlus,FPlus ); if (TermCode!=BFGS_NoTermination) return; if (FPlus<=pFunc+Alpha*Lambda*InitSp) { RetCode = 0; MaxTkn = (Lambda==Lambda0) && (NewtLn>0.99*MxStep); } else if (Lambda0.1*Lambda) Lambda = LamTem; else { Lambda *= 0.1; Lambda0 = Lambda; } if (Lambda>Lambda0) { Lambda = Lambda0; RetCode = 0; for (i=1;i<=N;i++) XPlus[i] = px0[i] + Lambda*P[i]; } } else { B1 = FPlus - pFunc - Lambda*InitSp; B2 = FplPre - pFunc - LamPre*InitSp; A = ( B1/(Lambda*Lambda) - B2/(LamPre*LamPre) ) / ( Lambda - LamPre ); B = ( -LamPre*B1/(Lambda*Lambda) + Lambda*B2/(LamPre*LamPre) ) / ( Lambda - LamPre ); Disc = B*B - 3.0*A*InitSp; if (A==0.0) LamTem = -InitSp/(2.0*B); else LamTem = (-B+sqrt(RMax(Disc,0.0)))/(3.0*A); B1 = 0.5*Lambda; if (B10.1*Lambda) Lambda = LamTem; else { Lambda *= 0.1; Lambda0 = Lambda; } if (Lambda>Lambda0) { Lambda = Lambda0; RetCode = 0; for (i=1;i<=N;i++) XPlus[i] = px0[i] + Lambda*P[i]; } } } while (RetCode>=2); TakenLambda = Lambda; } // ------------------------------------------------------------------- void CBFGSMin::GetMemory() { if (N!=NAlloc) { FreeMemory(); GetMatrixMemory ( Hsn , N,N, 1,1 ); GetVectorMemory ( GPlus , N, 1 ); GetVectorMemory ( GradX , N, 1 ); GetVectorMemory ( HDiag , N, 1 ); GetVectorMemory ( SN , N, 1 ); GetVectorMemory ( Sx , N, 1 ); GetVectorMemory ( XPlus , N, 1 ); GetVectorMemory ( XOpt , N, 1 ); GetVectorMemory ( Freese, N, 1 ); if (CalcHess) { GetVectorMemory ( StepSize , N, 1 ); GetVectorMemory ( FNeighbor, N, 1 ); } else { GetVectorMemory ( us , N, 1 ); GetVectorMemory ( uy , N, 1 ); GetVectorMemory ( ut , N, 1 ); } NAlloc = N; } } void CBFGSMin::FreeMemory() { if (NAlloc>0) { FreeVectorMemory ( us , 1 ); FreeVectorMemory ( uy , 1 ); FreeVectorMemory ( ut , 1 ); FreeVectorMemory ( Freese , 1 ); FreeVectorMemory ( StepSize , 1 ); FreeVectorMemory ( FNeighbor, 1 ); FreeVectorMemory ( XOpt , 1 ); FreeVectorMemory ( XPlus , 1 ); FreeVectorMemory ( Sx , 1 ); FreeVectorMemory ( SN , 1 ); FreeVectorMemory ( HDiag , 1 ); FreeVectorMemory ( GradX , 1 ); FreeVectorMemory ( GPlus , 1 ); FreeMatrixMemory ( Hsn , NAlloc, 1,1 ); } NAlloc = 0; } // ------------------------------------------------------------------- void CBFGSMin::Relax() { int i; if (FPlus>FOpt) { for (i=1;i<=N;i++) XPlus[i] = XOpt[i]; FPlus = FOpt; } else { for (i=1;i<=N;i++) XOpt[i] = XPlus[i]; FOpt = FPlus; } } void CBFGSMin::CopyPlus ( rvector x0 ) { int i; for (i=1;i<=N;i++) { x0 [i] = XPlus[i]; GradX[i] = GPlus[i]; } Func = FPlus; } // ------------------------------------------------------------------- void CBFGSMin::BFGS_Driver ( int MinN, rvector x0, rvector TypX, realtype & FuncValue, int & TerminationCode, int Digits, int ItnLmt, realtype TypF, realtype GrdTol, realtype StpTol, realtype MaxStp, Boolean Hess, rvector LowLimit, rvector TopLimit ) { // D6.1.1 : Unconstrained Minimization Driver int i,RetCode; int ItnCnt; Boolean MaxTkn; TL = TopLimit; LL = LowLimit; ForDiff = True; N = MinN; CalcHess = Hess; ModF = False; GetMemory(); UMInCk ( x0,TypX,Digits,TypF, GrdTol,StpTol,MaxStp, ItnLmt ); if (TermCode!=BFGS_NoTermination) { FreeMemory(); FuncValue = Func; TerminationCode = TermCode; return; } ItnCnt = 0; MinFunc1 ( x0,Func ); if (TermCode!=BFGS_NoTermination) { FreeMemory(); FuncValue = Func; TerminationCode = TermCode; return; } FOpt = Func; FPlus = Func; for (i=1;i<=N;i++) { XOpt [i] = x0[i]; XPlus[i] = x0[i]; } ModF = True; Gradient ( x0,GradX,Func ); Print ( ItnCnt,x0,GradX,Func ); for (i=1;i<=N;i++) GPlus[i] = GradX[i]; if (TermCode!=BFGS_NoTermination) { Relax (); CopyPlus ( x0 ); FreeMemory(); FuncValue = Func; TerminationCode = TermCode; return; } UMStop0 ( x0,GradX ); if (TermCode!=BFGS_NoTermination) { FreeMemory(); FuncValue = Func; TerminationCode = TermCode; return; } if (!CalcHess) InitHessUnFac ( Func,Hsn ); RetCode = 0; while (TermCode==BFGS_NoTermination) { ItnCnt++; if (RetCode>=0) { if (CalcHess) { FDHessF ( Func,x0 ); if (TermCode!=BFGS_NoTermination) { Relax (); CopyPlus ( x0 ); FreeMemory(); FuncValue = Func; TerminationCode = TermCode; return; } } MdHess ( Hsn,HDiag ); } ChSolve ( N,Hsn,GradX,SN ); LineSearch ( x0,GradX,SN,Func,RetCode,MaxTkn ); if ((RetCode==1) && ForDiff) { RetCode = -1; ForDiff = False; } else Relax(); if (TermCode!=BFGS_NoTermination) { Relax (); CopyPlus ( x0 ); FreeMemory(); FuncValue = Func; TerminationCode = TermCode; return; } else Gradient ( XPlus,GPlus,FPlus ); if (TermCode!=BFGS_NoTermination) { Relax (); CopyPlus ( x0 ); FreeMemory(); FuncValue = Func; TerminationCode = TermCode; return; } if (RetCode>=0) { UMStop ( x0,GPlus,RetCode,ItnCnt,MaxTkn ); if ((!CalcHess) && (TermCode==BFGS_NoTermination)) BFGSUnFac ( x0,XPlus,GradX,GPlus,False,HDiag,Hsn ); } CopyPlus ( x0 ); Print ( ItnCnt, x0,GradX,Func ); } Relax (); FreeMemory(); FuncValue = Func; TerminationCode = TermCode; } mmdb-1.25.5/mmdb/hybrid_36.h0000775000175000017500000000077411736610510012342 00000000000000/* If you change the include guards, please be sure to also rename the functions below. Otherwise your project will clash with the original iotbx declarations and definitions. */ #ifndef IOTBX_PDB_HYBRID_36_C_H #define IOTBX_PDB_HYBRID_36_C_H #ifdef __cplusplus extern "C" { #endif const char* hy36encode(unsigned width, int value, char* result); const char* hy36decode(unsigned width, const char* s, unsigned s_size, int* result); #ifdef __cplusplus } #endif #endif /* IOTBX_PDB_HYBRID_36_C_H */ mmdb-1.25.5/mmdb/mmdb_title.h0000775000175000017500000004342712162051331012665 00000000000000// $Id: mmdb_title.h,v 1.22 2012/01/26 17:52:21 ekr Exp $ // ================================================================= // // CCP4 Coordinate Library: support of coordinate-related // functionality in protein crystallography applications. // // Copyright (C) Eugene Krissinel 2000-2008. // // This library is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // // ================================================================= // // 23.06.13 <-- Date of Last Modification. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ----------------------------------------------------------------- // // **** Module : MMDB_Title // ~~~~~~~~~ // **** Project : MacroMolecular Data Base (MMDB) // ~~~~~~~~~ // **** Classes : CTitleContainer (container of title classes) // ~~~~~~~~~ CObsLine // CTitleLine // CCaveat // CCompound // CSource // CKeyWords // CExpData // CMdlType // CAuthor // CRevData // CSupersede // CJournal // CRemark // CBiomolecule // CMMDBTitle ( MMDB title section ) // // (C) E. Krissinel 2000-2013 // // ================================================================= // #ifndef __MMDB_Title__ #define __MMDB_Title__ #ifndef __Stream__ #include "stream_.h" #endif #ifndef __MMDB_Defs__ #include "mmdb_defs.h" #endif #ifndef __MMDB_Utils__ #include "mmdb_utils.h" #endif #ifndef __MMDB_MMCIF__ #include "mmdb_mmcif.h" #endif // ==================== CTitleContainer ====================== DefineClass(CTitleContainer); DefineStreamFunctions(CTitleContainer); class CTitleContainer : public CClassContainer { public : CTitleContainer () : CClassContainer() {} CTitleContainer ( RPCStream Object ) : CClassContainer ( Object ) {} ~CTitleContainer () {} PCContainerClass MakeContainerClass ( int ClassID ); }; // ================== CObsLine ======================== DefineClass(CObsLine); DefineStreamFunctions(CObsLine); class CObsLine : public CContainerClass { public : Date repDate; // date of replacement IDCode idCode; // ID code of replaced entry IDCode rIdCode[8]; // ID codes of entries that replaced this one CObsLine (); CObsLine ( cpstr S ); CObsLine ( RPCStream Object ); ~CObsLine(); void PDBASCIIDump ( pstr S, int N ); void MakeCIF ( PCMMCIFData CIF, int N ); int ConvertPDBASCII ( cpstr S ); void GetCIF ( PCMMCIFData CIF, int & Signal ); int GetClassID () { return ClassID_ObsLine; } void Copy ( PCContainerClass ObsLine ); void write ( RCFile f ); void read ( RCFile f ); protected : void InitObsLine(); }; // ==================== CTitleLine ===================== DefineClass(CTitleLine); DefineStreamFunctions(CTitleLine); class CTitleLine : public CContString { public : CTitleLine (); CTitleLine ( cpstr S ); CTitleLine ( RPCStream Object ); ~CTitleLine(); int ConvertPDBASCII ( cpstr S ); void PDBASCIIDump ( pstr S, int N ); Boolean PDBASCIIDump1 ( RCFile ) { return False; } int GetClassID () { return ClassID_TitleLine; } // void GetCIF ( PCMMCIFData CIF, int & Signal ); // void MakeCIF ( PCMMCIFData CIF, int N ); // void Copy ( PCContainerClass TitleLine ); void write ( RCFile f ); void read ( RCFile f ); protected : void InitTitleLine(); }; // ==================== CCaveat ===================== DefineClass(CCaveat); DefineStreamFunctions(CCaveat); class CCaveat : public CContString { public : IDCode idCode; // ID code of the entry CCaveat (); CCaveat ( cpstr S ); CCaveat ( RPCStream Object ); ~CCaveat(); void PDBASCIIDump ( pstr S, int N ); Boolean PDBASCIIDump1 ( RCFile ) { return False; } void MakeCIF ( PCMMCIFData CIF, int N ); int ConvertPDBASCII ( cpstr S ); void GetCIF ( PCMMCIFData CIF, int & Signal ); int GetClassID () { return ClassID_CAVEAT; } void Copy ( PCContainerClass Caveat ); void write ( RCFile f ); void read ( RCFile f ); protected : void InitCaveat(); }; // ==================== CCompound ===================== DefineClass(CCompound); DefineStreamFunctions(CCompound); class CCompound : public CContString { public : CCompound (); CCompound ( cpstr S ); CCompound ( RPCStream Object ); ~CCompound(); void PDBASCIIDump ( pstr S, int N ); Boolean PDBASCIIDump1 ( RCFile ) { return False; } int ConvertPDBASCII ( cpstr S ); int GetClassID () { return ClassID_Compound; } // void GetCIF ( PCMMCIFData CIF, int & Signal ); // void MakeCIF ( PCMMCIFData CIF, int N ); // void Copy ( PCContainerClass Compound ); void write ( RCFile f ); void read ( RCFile f ); protected : void InitCompound(); }; // ==================== CSource ===================== DefineClass(CSource); DefineStreamFunctions(CSource); class CSource : public CContString { public : CSource (); CSource ( cpstr S ); CSource ( RPCStream Object ); ~CSource(); void PDBASCIIDump ( pstr S, int N ); Boolean PDBASCIIDump1 ( RCFile ) { return False; } int ConvertPDBASCII ( cpstr S ); int GetClassID () { return ClassID_Source; } // void GetCIF ( PCMMCIFData CIF, int & Signal ); // void MakeCIF ( PCMMCIFData CIF, int N ); // void Copy ( PCContainerClass Source ); void write ( RCFile f ); void read ( RCFile f ); protected : void InitSource(); }; // ==================== CKeyWords ===================== DefineClass(CKeyWords); DefineStreamFunctions(CKeyWords); class CKeyWords : public CStream { public : int nKeyWords; // number of key words psvector KeyWord; // key word array CKeyWords (); CKeyWords ( cpstr S ); CKeyWords ( RPCStream Object ); ~CKeyWords(); void Delete (); void PDBASCIIDump ( RCFile f ); void MakeCIF ( PCMMCIFData CIF ); int ConvertPDBASCII ( cpstr S ); void GetCIF ( PCMMCIFData CIF ); void Copy ( PCKeyWords KeyWords ); void write ( RCFile f ); void read ( RCFile f ); protected : Boolean Cont; void Init(); }; // ==================== CExpData ===================== DefineClass(CExpData); DefineStreamFunctions(CExpData); class CExpData : public CContString { public : CExpData (); CExpData ( cpstr S ); CExpData ( RPCStream Object ); ~CExpData(); void PDBASCIIDump ( pstr S, int N ); Boolean PDBASCIIDump1 ( RCFile ) { return False; } int ConvertPDBASCII ( cpstr S ); int GetClassID () { return ClassID_ExpData; } // void GetCIF ( PCMMCIFData CIF, int & Signal ); // void MakeCIF ( PCMMCIFData CIF, int N ); // void Copy ( PCContainerClass ExpData ); void write ( RCFile f ); void read ( RCFile f ); protected : void InitExpData(); }; // ==================== CMdlType ===================== DefineClass(CMdlType); DefineStreamFunctions(CMdlType); class CMdlType : public CContString { public : CMdlType (); CMdlType ( cpstr S ); CMdlType ( RPCStream Object ); ~CMdlType(); void PDBASCIIDump ( pstr S, int N ); Boolean PDBASCIIDump1 ( RCFile ) { return False; } int ConvertPDBASCII ( cpstr S ); int GetClassID () { return ClassID_MdlType; } // void GetCIF ( PCMMCIFData CIF, int & Signal ); // void MakeCIF ( PCMMCIFData CIF, int N ); // void Copy ( PCContainerClass ExpData ); void write ( RCFile f ); void read ( RCFile f ); protected : void InitMdlType(); }; // ==================== CAuthor ===================== DefineClass(CAuthor); DefineStreamFunctions(CAuthor); class CAuthor : public CContString { public : CAuthor (); CAuthor ( cpstr S ); CAuthor ( RPCStream Object ); ~CAuthor(); void PDBASCIIDump ( pstr S, int N ); Boolean PDBASCIIDump1 ( RCFile ) { return False; } int ConvertPDBASCII ( cpstr S ); int GetClassID () { return ClassID_Author; } // void GetCIF ( PCMMCIFData CIF, int & Signal ); // void MakeCIF ( PCMMCIFData CIF, int N ); // void Copy ( PCContainerClass Author ); void write ( RCFile f ); void read ( RCFile f ); protected : void InitAuthor(); }; // ==================== CRevData ===================== DefineClass(CRevData); DefineStreamFunctions(CRevData); #define REVDAT_WARN_MODNUM 0x00000001 #define REVDAT_WARN_MODTYPE 0x00000002 class CRevData : public CContainerClass { public : int modNum; Date modDate; char modId[13]; int modType; RecName record[4]; word Warning; CRevData (); CRevData ( cpstr S ); CRevData ( RPCStream Object ); ~CRevData(); void PDBASCIIDump ( pstr S, int N ); void MakeCIF ( PCMMCIFData CIF, int N ); int ConvertPDBASCII ( cpstr S ); void GetCIF ( PCMMCIFData CIF, int & Signal ); int GetClassID () { return ClassID_RevData; } void Copy ( PCContainerClass RevData ); void write ( RCFile f ); void read ( RCFile f ); protected : void InitRevData(); }; // ================== CSupersede ======================== DefineClass(CSupersede); DefineStreamFunctions(CSupersede); class CSupersede : public CContainerClass { public : Date sprsdeDate; // date of supersede IDCode idCode; // ID code of the entry IDCode sIdCode[8]; // ID codes of superseded entries CSupersede (); CSupersede ( cpstr S ); CSupersede ( RPCStream Object ); ~CSupersede(); void PDBASCIIDump ( pstr S, int N ); void MakeCIF ( PCMMCIFData CIF, int N ); int ConvertPDBASCII ( cpstr S ); void GetCIF ( PCMMCIFData CIF, int & Signal ); int GetClassID () { return ClassID_Supersede; } void Copy ( PCContainerClass Supersede ); void write ( RCFile f ); void read ( RCFile f ); protected : void InitSupersede(); }; // ==================== CJournal ===================== DefineClass(CJournal); DefineStreamFunctions(CJournal); class CJournal : public CContString { public : CJournal (); CJournal ( cpstr S ); CJournal ( RPCStream Object ); ~CJournal(); void PDBASCIIDump ( pstr S, int N ); Boolean PDBASCIIDump1 ( RCFile ) { return False; } int ConvertPDBASCII ( cpstr S ); int GetClassID () { return ClassID_Journal; } // void GetCIF ( PCMMCIFData CIF, int & Signal ); // void MakeCIF ( PCMMCIFData CIF, int N ); // void Copy ( PCContainerClass Journal ); void write ( RCFile f ); void read ( RCFile f ); protected : void InitJournal(); }; // ==================== CRemark ===================== DefineClass(CRemark); DefineStreamFunctions(CRemark); class CRemark : public CContainerClass { public : int remarkNum; // remark id pstr Remark; // remark line CRemark (); CRemark ( cpstr S ); CRemark ( RPCStream Object ); ~CRemark(); void PDBASCIIDump ( pstr S, int N ); void MakeCIF ( PCMMCIFData CIF, int N ); int ConvertPDBASCII ( cpstr S ); void GetCIF ( PCMMCIFData CIF, int & Signal ); int GetClassID () { return ClassID_Remark; } void Copy ( PCContainerClass RemarkClass ); void write ( RCFile f ); void read ( RCFile f ); protected : void InitRemark(); }; // ================= CBiomolecule ===================== DefineClass(CBMApply); DefineStreamFunctions(CBMApply); class CBMApply : public CStream { public : PChainID chain; int nChains; pmat44 tm; int nMatrices; CBMApply (); CBMApply ( RPCStream Object ); ~CBMApply(); void FreeMemory(); int addChains ( int & i, RPCRemark rem, RCTitleContainer Remark ); int addMatrices ( int & i, RPCRemark rem, RCTitleContainer Remark ); void Copy ( PCBMApply BMA ); // if BMA is NULL, then empties // the class void write ( RCFile f ); void read ( RCFile f ); protected : void InitBMApply(); }; DefineClass(CBiomolecule); DefineStreamFunctions(CBiomolecule); class CBiomolecule : public CStream { public : PPCBMApply BMApply; int nBMAs; CBiomolecule (); CBiomolecule ( RPCStream Object ); ~CBiomolecule(); void FreeMemory(); PCBMApply addBMApply(); int Size(); Boolean checkComposition ( PChainID chID, ivector occ, ivector wocc, int n ); void Copy ( PCBiomolecule B ); // if B is NULL, then empties // the class void write ( RCFile f ); void read ( RCFile f ); protected : void InitBiomolecule(); }; // ================= CMMDBTitle ======================= DefineClass(CMMDBTitle); DefineStreamFunctions(CMMDBTitle); class CMMDBTitle : public CStream { friend class CModel; friend class CChain; friend class CMMDBFile; public : CMMDBTitle (); CMMDBTitle ( RPCStream Object ); ~CMMDBTitle(); void FreeMemory ( Boolean keepBiomolecules ); // Fills the PDB file header void SetHeader ( cpstr Classification, // any length is Ok cpstr DepDate, // DD-MMM-YYYY cpstr ID_Code ); // not more than 11 chars // Interprets the ASCII PDB line belonging to the title section // and fills the corresponding fields. // Returns zero if the line was converted, otherwise returns a // non-negative value of Error_XXXX. // PDBString must be not shorter than 81 characters. int ConvertPDBString ( pstr PDBString ); // MakePDBString() makes the ASCII PDB HEADER line from the // class data. PDBString must be not shorter than 81 characters. void MakePDBHeaderString ( pstr PDBString ); // GetStructureTitle() returns the contents of TITLE record // unfolded into single line. If Title is missing, returns // contents of COMPND(:MOLECULE). If COMPND is missing, returns // HEADER. If Header is missing, returns PDB code. If no PDB // code is there, returns "Not available". pstr GetStructureTitle ( pstr & S ); PCTitleContainer GetRemarks(); PCTitleContainer GetJournal(); realtype GetResolution(); // -1.0 mean no resolution record in file int ParseBiomolecules(); // returns the number of biomolecules, // -2 for general format error // -3 for errors in BIOMT records int GetNofBiomolecules(); void GetBiomolecules ( PPCBiomolecule & BM, int & nBMs ); PCBiomolecule GetBiomolecule ( int bmNo ); // bmno=0,1,.. // returns NULL if bmNo is incorrect void PDBASCIIDump ( RCFile f ); void MakeCIF ( PCMMCIFData CIF ); // GetCIF(..) returns the same code as ConvertPDBString(..) // save for Error_WrongSection int GetCIF ( PCMMCIFData CIF ); pstr GetIDCode() { return idCode; } Boolean GetCol73() { return col73; } void TrimInput ( pstr PDBString ); void Copy ( PCMMDBTitle TS ); // if TS is NULL, then empties // the class void write ( RCFile f ); // writes header to PDB binary file void read ( RCFile f ); // reads header from PDB binary file protected : // Header data pstr classification; // classification of the molecule Date depDate; // deposition date DD-MMM-YYYY IDCode idCode; // unique PDB identifier realtype resolution; // resolution Boolean col73; // True if columns 73-80 contain PDB ID CTitleContainer ObsData; // obsoletion data CTitleContainer Title; // title data CTitleContainer CAVEAT; // error data CTitleContainer Compound; // compound data CTitleContainer Source; // source CKeyWords KeyWords; // key words CTitleContainer ExpData; // experimental data CTitleContainer MdlType; // model desctiptions CTitleContainer Author; // author data CTitleContainer RevData; // revision data CTitleContainer Supersede; // supersede records CTitleContainer Journal; // journal records CTitleContainer Remark; // remark records PPCBiomolecule Biomolecule; int nBiomolecules; void Init(); void FreeBiomolecules(); PCBiomolecule addBiomolecule(); }; extern void TestHeader(); extern void TestTitle (); // reads PDB title from file 'in.title' // and rewrites it into 'out.title' and // 'abin.title' #endif mmdb-1.25.5/mmdb/mmdb_model.h0000775000175000017500000011114111736610510012637 00000000000000// $Id: mmdb_model.h,v 1.25 2012/01/26 17:52:20 ekr Exp $ // ================================================================= // // CCP4 Coordinate Library: support of coordinate-related // functionality in protein crystallography applications. // // Copyright (C) Eugene Krissinel 2000-2008. // // This library is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // // ================================================================= // // 30.04.10 <-- Date of Last Modification. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ----------------------------------------------------------------- // // **** Module : MMDB_Model // ~~~~~~~~~ // **** Project : MacroMolecular Data Base (MMDB) // ~~~~~~~~~ // **** Classes : CHetCompound ( description of het compounds ) // ~~~~~~~~~ CHetCompounds ( HETNAM, HETSYN, FORMULA records ) // CSSContainer ( container for helixes and turns ) // CHelix ( helix info ) // CStrand ( strand info ) // CSheet ( sheet info ) // CSheets ( container for sheets ) // CTurn ( turn info ) // CLinkContainer ( container for link data ) // CLink ( link data ) // CLinkRContainer ( container for refmac link ) // CLinkR ( link data ) // CCisPepContainer ( container for CisPep data ) // CCisPep ( CisPep data ) // CModel ( PDB model ) // // Copyright (C) E. Krissinel 2000-2010 // // ================================================================= // #ifndef __MMDB_Model__ #define __MMDB_Model__ #ifndef __Stream__ #include "stream_.h" #endif #ifndef __MMDB_Defs__ #include "mmdb_defs.h" #endif #ifndef __MMDB_Utils__ #include "mmdb_utils.h" #endif #ifndef __MMDB_Chain__ #include "mmdb_chain.h" #endif // ==================== CHetCompound ======================= DefineClass(CHetCompound); DefineStreamFunctions(CHetCompound); class CHetCompound : public CStream { public : ResName hetID; // Het identifiers, right-justified pstr comment; int nSynonyms; psvector hetSynonym; // synonyms int compNum; // component number char wc; // '*' for water, otherwise space pstr Formula; // formulas CHetCompound ( cpstr HetName ); CHetCompound ( RPCStream Object ); ~CHetCompound(); void AddKeyWord ( cpstr W, Boolean Closed ); void HETNAM_PDBDump ( RCFile f ); void HETSYN_PDBDump ( RCFile f ); void FORMUL_PDBDump ( RCFile f ); void FormComString ( pstr & F ); void FormSynString ( pstr & F ); void FormForString ( pstr & F ); void Copy ( PCHetCompound HetCompound ); void write ( RCFile f ); void read ( RCFile f ); protected : void InitHetCompound ( cpstr HetName ); void FreeMemory (); }; // ==================== CSSContainer ====================== DefineClass(CSSContainer); DefineStreamFunctions(CSSContainer); class CSSContainer : public CClassContainer { public : CSSContainer () : CClassContainer() {} CSSContainer ( RPCStream Object ) : CClassContainer ( Object ) {} ~CSSContainer () {} PCContainerClass MakeContainerClass ( int ClassID ); }; // ==================== CHelix ============================ DefineClass(CHelix); DefineStreamFunctions(CHelix); class CHelix : public CContainerClass { public : int serNum; // serial number HelixID helixID; // helix ID ResName initResName; // name of the helix's initial residue ChainID initChainID; // chain ID for the chain containing the helix int initSeqNum; // sequence number of the initial residue InsCode initICode; // insertion code of the initial residue ResName endResName; // name of the helix's terminal residue ChainID endChainID; // chain ID for the chain containing the helix int endSeqNum; // sequence number of the terminal residue InsCode endICode; // insertion code of the terminal residue int helixClass; // helix class pstr comment; // comment about the helix int length; // length of the helix CHelix (); CHelix ( cpstr S ); CHelix ( RPCStream Object ); ~CHelix(); void PDBASCIIDump ( pstr S, int N ); void MakeCIF ( PCMMCIFData CIF, int N ); int ConvertPDBASCII ( cpstr S ); void GetCIF ( PCMMCIFData CIF, int & Signal ); int GetClassID () { return ClassID_Helix; } void Copy ( PCContainerClass Helix ); void write ( RCFile f ); void read ( RCFile f ); protected : void InitHelix(); }; // ==================== CStrand ============================ DefineClass(CStrand); DefineStreamFunctions(CStrand); class CStrand : public CStream { public : StrandID sheetID; // sheet ID int strandNo; // strand number ResName initResName; // name of the strand's initial residue ChainID initChainID; // chain ID of initial residue in the strand int initSeqNum; // sequence number of the initial residue InsCode initICode; // insertion code of the initial residue ResName endResName; // name of the strand's terminal residue ChainID endChainID; // chain ID of terminal residue in the strand int endSeqNum; // sequence number of the terminal residue InsCode endICode; // insertion code of the terminal residue int sense; // sense of strand with respect to previous // strand AtomName curAtom; // registration; atom name in current strand ResName curResName; // registration; residue name in current // strand ChainID curChainID; // registration; chain ID in current strand int curResSeq; // registration; res-e seq numb in current // strand InsCode curICode; // registration; ins code in current strand AtomName prevAtom; // registration; atom name in previous strand ResName prevResName; // registration; residue name in previous // strand ChainID prevChainID; // registration; chain ID in previous strand int prevResSeq; // registration; res-e seq numb in previous // strand InsCode prevICode; // registration; ins code in previous strand CStrand (); CStrand ( RPCStream Object ); ~CStrand(); void PDBASCIIDump ( pstr S ); void MakeCIF ( PCMMCIFData CIF ); int ConvertPDBASCII ( cpstr S ); int GetCIF ( PCMMCIFData CIF, cpstr sheet_id ); void Copy ( PCStrand Strand ); void write ( RCFile f ); void read ( RCFile f ); protected : void InitStrand(); }; // ==================== CSheet ============================ DefineClass(CSheet); DefineStreamFunctions(CSheet); class CSheet : public CStream { public : SheetID sheetID; // sheet ID int nStrands; // number of strands in the sheet PPCStrand Strand; // array of strands CSheet (); CSheet ( RPCStream Object ); ~CSheet(); void FreeMemory(); void OrderSheet(); void PDBASCIIDump ( RCFile f ); void MakeCIF ( PCMMCIFData CIF ); int ConvertPDBASCII ( cpstr S ); int GetCIF ( PCMMCIFData CIF ); void Copy ( PCSheet Sheet ); void write ( RCFile f ); void read ( RCFile f ); protected : void InitSheet (); void CIFFindStrands ( PCMMCIFData CIF, cpstr Category ); void TryStrand ( int strand_no ); int GetStrand ( int strand_no ); }; // ==================== CSheets ============================ DefineClass(CSheets); DefineStreamFunctions(CSheets); class CSheets : public CStream { public : int nSheets; PPCSheet Sheet; CSheets (); CSheets ( RPCStream Object ); ~CSheets(); void FreeMemory(); void PDBASCIIDump ( RCFile f ); void MakeCIF ( PCMMCIFData CIF ); int ConvertPDBASCII ( cpstr S ); int GetCIF ( PCMMCIFData CIF ); void Copy ( PCSheets Sheets ); void write ( RCFile f ); void read ( RCFile f ); protected : void InitSheets (); void CIFFindSheets ( PCMMCIFData CIF, cpstr Category ); }; // ==================== CTurn ============================ DefineClass(CTurn); DefineStreamFunctions(CTurn); class CTurn : public CContainerClass { public : int serNum; // serial number TurnID turnID; // turn ID ResName initResName; // name of the turn's initial residue ChainID initChainID; // chain ID for the chain containing the turn int initSeqNum; // sequence number of the initial residue InsCode initICode; // insertion code of the initial residue ResName endResName; // name of the turn's terminal residue ChainID endChainID; // chain ID for the chain containing the turn int endSeqNum; // sequence number of the terminal residue InsCode endICode; // insertion code of the terminal residue pstr comment; // comment about the helix CTurn (); CTurn ( cpstr S ); CTurn ( RPCStream Object ); ~CTurn(); void PDBASCIIDump ( pstr S, int N ); void MakeCIF ( PCMMCIFData CIF, int N ); int ConvertPDBASCII ( cpstr S ); void GetCIF ( PCMMCIFData CIF, int & Signal ); int GetClassID () { return ClassID_Turn; } void Copy ( PCContainerClass Turn ); void write ( RCFile f ); void read ( RCFile f ); protected : void InitTurn(); }; // ==================== CHetCompounds ======================= DefineClass(CHetCompounds); DefineStreamFunctions(CHetCompounds); class CHetCompounds : public CStream { public : int nHets; PPCHetCompound hetCompound; CHetCompounds (); CHetCompounds ( RPCStream Object ); ~CHetCompounds(); void FreeMemory (); void PDBASCIIDump ( RCFile f ); void ConvertHETNAM ( cpstr S ); void ConvertHETSYN ( cpstr S ); void ConvertFORMUL ( cpstr S ); void MakeCIF ( PCMMCIFData CIF ); void GetCIF ( PCMMCIFData CIF ); void Copy ( PCHetCompounds HetCompounds ); void write ( RCFile f ); void read ( RCFile f ); protected : Boolean Closed; void InitHetCompounds(); int AddHetName ( cpstr H ); }; // =================== CLinkContainer ===================== DefineClass(CLinkContainer); DefineStreamFunctions(CLinkContainer); class CLinkContainer : public CClassContainer { public : CLinkContainer () : CClassContainer() {} CLinkContainer ( RPCStream Object ) : CClassContainer ( Object ) {} ~CLinkContainer () {} PCContainerClass MakeContainerClass ( int ClassID ); }; // ==================== CLink ============================ DefineClass(CLink); DefineStreamFunctions(CLink); class CLink : public CContainerClass { public : AtomName atName1; // name of 1st linked atom AltLoc aloc1; // alternative location of 1st linked atom ResName resName1; // residue name of 1st linked atom ChainID chainID1; // chain ID of 1st linked atom int seqNum1; // sequence number of 1st linked atom InsCode insCode1; // insertion code of 1st linked atom AtomName atName2; // name of 2nd linked atom AltLoc aloc2; // alternative location of 2nd linked atom ResName resName2; // residue name of 2nd linked atom ChainID chainID2; // chain ID of 2nd linked atom int seqNum2; // sequence number of 2nd linked atom InsCode insCode2; // insertion code of 2nd linked atom int s1,i1,j1,k1; // sym id of 1st atom int s2,i2,j2,k2; // sym id of 2nd atom CLink (); CLink ( cpstr S ); CLink ( RPCStream Object ); ~CLink(); void PDBASCIIDump ( pstr S, int N ); void MakeCIF ( PCMMCIFData CIF, int N ); int ConvertPDBASCII ( cpstr S ); void GetCIF ( PCMMCIFData CIF, int & Signal ); int GetClassID () { return ClassID_Link; } void Copy ( PCContainerClass Link ); void write ( RCFile f ); void read ( RCFile f ); protected : void InitLink(); }; // =================== CLinkRContainer ==================== DefineClass(CLinkRContainer); DefineStreamFunctions(CLinkRContainer); class CLinkRContainer : public CClassContainer { public : CLinkRContainer () : CClassContainer() {} CLinkRContainer ( RPCStream Object ) : CClassContainer ( Object ) {} ~CLinkRContainer () {} PCContainerClass MakeContainerClass ( int ClassID ); }; // ==================== CLinkR ============================ DefineClass(CLinkR); DefineStreamFunctions(CLinkR); /* Garib's LINK LYS A 27 PLP A 255 PLPLYS LINK MAN S 3 MAN S 4 BETA1-4 LINK C6 BBEN B 1 O1 BMAF S 2 BEN-MAF LINK OE2 AGLU A 320 C1 AMAF S 2 GLU-MAF LINK OE2 GLU A 67 1.895 ZN ZN R 5 GLU-ZN LINK NE2 HIS A 71 2.055 ZN ZN R 5 HIS-ZN LINK O ARG A 69 2.240 NA NA R 9 ARG-NA Coot's LINKR O VAL C 103 NA NA C 401 VAL-NA LINKR OD1 ASP D 58 NA NA D 401 ASP-NA LINKR O ALA D 97 NA NA D 401 ALA-NA LINKR OG1 THR D 99 NA NA D 401 THR-NA LINKR O SER D 101 NA NA D 401 SER-NA LINKR O VAL D 103 NA NA D 401 VAL-NA PDB's LINK O GLY A 49 NA NA A6001 1555 1555 2.98 LINK OG1 THR A 51 NA NA A6001 1555 1555 2.72 LINK OD2 ASP A 66 NA NA A6001 1555 1555 2.72 LINK NE ARG A 68 NA NA A6001 1555 1555 2.93 LINK NE ARG A 68 NA NA A6001 1555 1555 2.93 LINK C21 2EG A 7 C22 2EG B 19 1555 1555 1.56 */ class CLinkR : public CContainerClass { public : LinkRID linkRID; // link name AtomName atName1; // name of 1st linked atom AltLoc aloc1; // alternative location of 1st linked atom ResName resName1; // residue name of 1st linked atom ChainID chainID1; // chain ID of 1st linked atom int seqNum1; // sequence number of 1st linked atom InsCode insCode1; // insertion code of 1st linked atom AtomName atName2; // name of 2nd linked atom AltLoc aloc2; // alternative location of 2nd linked atom ResName resName2; // residue name of 2nd linked atom ChainID chainID2; // chain ID of 2nd linked atom int seqNum2; // sequence number of 2nd linked atom InsCode insCode2; // insertion code of 2nd linked atom realtype dist; // link distance CLinkR (); CLinkR ( cpstr S ); CLinkR ( RPCStream Object ); ~CLinkR(); void PDBASCIIDump ( pstr S, int N ); void MakeCIF ( PCMMCIFData CIF, int N ); int ConvertPDBASCII ( cpstr S ); void GetCIF ( PCMMCIFData CIF, int & Signal ); int GetClassID () { return ClassID_LinkR; } void Copy ( PCContainerClass LinkR ); void write ( RCFile f ); void read ( RCFile f ); protected : void InitLinkR(); }; // =================== CCisPepContainer ===================== DefineClass(CCisPepContainer); DefineStreamFunctions(CCisPepContainer); class CCisPepContainer : public CClassContainer { public : CCisPepContainer () : CClassContainer() {} CCisPepContainer ( RPCStream Object ) : CClassContainer ( Object ) {} ~CCisPepContainer () {} PCContainerClass MakeContainerClass ( int ClassID ); }; // ===================== CCisPep =========================== DefineClass(CCisPep); DefineStreamFunctions(CCisPep); class CCisPep : public CContainerClass { public : int serNum; // record serial number ResName pep1; // residue name ChainID chainID1; // chain identifier 1 int seqNum1; // residue sequence number 1 InsCode icode1; // insertion code 1 ResName pep2; // residue name 2 ChainID chainID2; // chain identifier 2 int seqNum2; // residue sequence number 2 InsCode icode2; // insertion code 2 int modNum; // model number realtype measure; // measure of the angle in degrees. CCisPep (); CCisPep ( cpstr S ); CCisPep ( RPCStream Object ); ~CCisPep(); void PDBASCIIDump ( pstr S, int N ); int ConvertPDBASCII ( cpstr S ); // void MakeCIF ( PCMMCIFData CIF, int N ); // void GetCIF ( PCMMCIFData CIF, int & Signal ); int GetClassID () { return ClassID_CisPep; } void Copy ( PCContainerClass CisPep ); void write ( RCFile f ); void read ( RCFile f ); protected : void InitCisPep(); }; // ==================== CModel =============================== #define SSERC_Ok 0 #define SSERC_noResidues 1 #define SSERC_noAminoacids 2 #define SSERC_noSSE 3 #define SORT_CHAIN_ChainID_Asc 0 #define SORT_CHAIN_ChainID_Desc 1 DefineFactoryFunctions(CModel); class CModel : public CProModel { friend class CMMDBManager; friend class CMMDBBondManager; friend class CMMDBSelManager; friend class CMMDBCoorManager; friend class CMMDBFile; friend class CChain; friend class CResidue; friend class CAtom; public : CModel (); // SetMMDBFile() MUST be used after this constructor! CModel ( PCMMDBManager MMDBF, int serialNum ); CModel ( RPCStream Object ); ~CModel(); void SetMMDBManager ( PCMMDBManager MMDBM, int serialNum ); PCMMDBManager GetCoordHierarchy() { return manager; } // GetChainCreate() returns pointer on chain, whose identifier // is given in chID. If such a chain is absent in the model, // it is created. If enforceUniqueChainID is True and chain with // the same first letter in chain ID already exists in the model, // then the new chain ID will be appended with a serial number // in order to keep it unique. The model will contain chains like // A, A0, A1, A2, ... in such cases. PCChain GetChainCreate ( const ChainID chID, Boolean enforceUniqueChainID ); // CreateChain() creates a new chain with chain ID regardless // the presence of same-ID chains in the model. This function // was introduced only for compatibility with older CCP4 // applications and using it in any new developments should be // strictly discouraged. PCChain CreateChain ( const ChainID chID ); cpstr GetEntryID (); void SetEntryID ( const IDCode idCode ); int GetSerNum (); // returns the model's serial number cpstr GetModelID ( pstr modelID ); // returns "/mdl" int GetNumberOfModels (); // returns TOTAL number of models int GetNumberOfAtoms ( Boolean countTers ); // returns number // of atoms in the model int GetNumberOfResidues(); // returns number of residues in // the model // ---------------- Extracting chains -------------------------- int GetNumberOfChains(); // returns number of chains in the model Boolean GetNewChainID ( ChainID chID, int length=1 ); // GetChain() returns pointer on chain, whose identifier // is given in chID. If such a chain is absent in the model, // returns NULL. PCChain GetChain ( const ChainID chID ); PCChain GetChain ( int chainNo ); // returns chainNo-th chain // in the model; // 0<=chainNoindex-1; atom[]->index // is assigned automatically. void MoveChain ( PCChain & m_chain, PPCAtom m_atom, PPCAtom atom, int & atom_index, int chain_ext ); void GetAIndexRange ( int & i1, int & i2 ); void MaskAtoms ( PCMask Mask ); void MaskResidues ( PCMask Mask ); void MaskChains ( PCMask Mask ); void UnmaskAtoms ( PCMask Mask ); void UnmaskResidues ( PCMask Mask ); void UnmaskChains ( PCMask Mask ); // ---- Getting Secondary Structure Elements int GetNumberOfHelices (); int GetNumberOfSheets (); PCHelix GetHelix ( int serialNum ); // 1<=serNum<=NofHelices void GetSheetID ( int serialNum, SheetID sheetID ); // '\0' for none PCSheet GetSheet ( int serialNum ); //1<=serNum<=NofSheets PCSheet GetSheet ( const SheetID sheetID ); // NULL for none int GetNumberOfStrands ( int sheetSerNum ); int GetNumberOfStrands ( const SheetID sheetID ); PCStrand GetStrand ( int sheetSerNum, int strandSerNum ); PCStrand GetStrand ( const SheetID sheetID, int strandSerNum ); PCSSContainer GetHelices() { return &Helices; } PCSheets GetSheets () { return &Sheets; } void RemoveSecStructure(); int CalcSecStructure ( Boolean flagBulge=True, int aminoSelHnd=-1 ); // int CalcSecStructure ( Boolean flagBulge=True ); void RemoveHetInfo (); // ---- Working Links int GetNumberOfLinks (); PCLink GetLink ( int serialNum ); // 1<=serNum<=NofLinks PCLinkContainer GetLinks() { return &Links; } void RemoveLinks(); void AddLink ( PCLink Link ); // ---- Working Refmac Links int GetNumberOfLinkRs (); PCLinkR GetLinkR ( int serialNum ); // 1<=serNum<=NofLinks PCLinkRContainer GetLinkRs() { return &LinkRs; } void RemoveLinkRs(); void AddLinkR ( PCLinkR LinkR ); // ---- Working CisPeps int GetNumberOfCisPeps(); PCCisPep GetCisPep ( int CisPepNum ); PCCisPepContainer GetCisPeps() { return &CisPeps; } void RemoveCisPeps(); void AddCisPep ( PCCisPep CisPep ); void ApplyTransform ( mat44 & TMatrix ); // transforms all // coordinates by multiplying // with matrix TMatrix Boolean isInSelection ( int selHnd ); // ------- user-defined data handlers int PutUDData ( int UDDhandle, int iudd ); int PutUDData ( int UDDhandle, realtype rudd ); int PutUDData ( int UDDhandle, cpstr sudd ); int GetUDData ( int UDDhandle, int & iudd ); int GetUDData ( int UDDhandle, realtype & rudd ); int GetUDData ( int UDDhandle, pstr sudd, int maxLen ); int GetUDData ( int UDDhandle, pstr & sudd ); void Copy ( PCModel Model ); void CopyHets ( PCModel Model ); void CopySecStructure ( PCModel Model ); void CopyLinks ( PCModel Model ); void CopyLinkRs ( PCModel Model ); void CopyCisPeps ( PCModel Model ); void write ( RCFile f ); void read ( RCFile f ); protected : int serNum; // the model serial number PCMMDBManager manager; // pointer to mmdbmanager class CHetCompounds HetCompounds; // information on heterocompounds CSSContainer Helices; // information on helices CSheets Sheets; // information on sheets CSSContainer Turns; // information on turns CLinkContainer Links; // information on links CLinkRContainer LinkRs; // information on refmac links CCisPepContainer CisPeps; // information on cispeps int nChains; // number of chains int nChainsAlloc; // actual length of Chain[] PPCChain Chain; // array of chains Boolean Exclude; // used internally void InitModel (); void FreeMemory (); void ExpandChainArray ( int nOfChains ); int GetCIFPSClass ( PCMMCIFData CIF, int ClassID ); // _ExcludeChain(..) excludes (but does not dispose!) a chain // from the model. Returns 1 if the chain gets empty and 0 // otherwise. int _ExcludeChain ( const ChainID chainID ); // _copy(PCModel) does not copy atoms! -- not for use in // applications void _copy ( PCModel Model ); // _copy(PCModel,PPCAtom,int&) does copy atoms into array 'atom' // starting from position atom_index. 'atom' should be able to // accept all new atoms - no checks on the length of 'atom' // is being made. This function should not be used in applications. void _copy ( PCModel Model, PPCAtom atom, int & atom_index ); void CheckInAtoms (); }; #endif mmdb-1.25.5/mmdb/mmdb_defs.h0000775000175000017500000002157012162051331012460 00000000000000// $Id: mmdb_defs.h,v 1.27 2012/01/26 17:52:20 ekr Exp $ // ================================================================= // // CCP4 Coordinate Library: support of coordinate-related // functionality in protein crystallography applications. // // Copyright (C) Eugene Krissinel 2000-2008. // // This library is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // // ================================================================= // // 23.06.13 <-- Date of Last Modification. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ----------------------------------------------------------------- // // **** Module : MMDBF_Defs // ~~~~~~~~~ // **** Project : MacroMolecular Data Base (MMDB) // ~~~~~~~~~ // // Definition of types, constants and important classes. // // (C) E. Krissinel 2000-2013 // // ================================================================= // #ifndef __MMDB_Defs__ #define __MMDB_Defs__ #ifndef __MatType__ #include "mattype_.h" #endif #define MMDB_MAJOR_VERSION (1) #define MMDB_MINOR_VERSION (25) #define MMDB_MICRO_VERSION (5) // ======================= types ================================= typedef char IDCode [16]; // ID code of the entry typedef IDCode * PIDCode; // pointer to ID code typedef PIDCode & RPIDCode; // ref-ce to pointer to ID code typedef char Date [12]; // date DD-MMM-YYYY typedef char RecName [7]; // name of PDB record typedef char ChainID [10]; // chain ID typedef ChainID * PChainID; // pointer to chain ID typedef char InsCode [10]; // insertion code typedef char DBName [10]; // sequence database name typedef char DBAcCode[20]; // seq. database accession code typedef DBAcCode * PDBAcCode; // pointer to seq. db acc code typedef char DBIdCode[20]; // seq. database ident-n code typedef DBIdCode * PDBIdCode; // pointer to DBIdCode typedef char ResName [20]; // residue name typedef ResName * PResName; // pointer to residue name typedef PResName * PPResName; // ptr to vector of residue names typedef char HelixID [20]; // helix ID typedef char StrandID[20]; // strand ID typedef char SheetID [20]; // sheet ID typedef char TurnID [20]; // turn ID typedef char LinkRID [20]; // Refmac link ID typedef char SymGroup[100]; // group of space symmetry typedef realtype vect3 [3]; // vector of 3 real numbers typedef vect3 * pvect3; typedef pvect3 & rpvect3; typedef realtype vect4 [4]; // vector of 4 real numbers typedef vect3 mat33 [3]; // matrix 3x3 of real numbers typedef vect4 mat44 [4]; // matrix 4x4 of real numbers typedef mat44 * pmat44; typedef mat44 & rmat44; typedef pmat44 * ppmat44; typedef pmat44 & rpmat44; typedef mat33 mat633 [6]; // matrix 6x3x3 of real numbers typedef char AtomName[20]; // name of the atom typedef AtomName * PAtomName; // pointer to atom name typedef char AltLoc [20]; // alternate location indicator typedef AltLoc * PAltLoc; // pointer to alt loc indicator typedef char SegID [20]; // segment identifier typedef char Element [10]; // chemical element name typedef Element * PElement; // ptr to chemical element name typedef char EnergyType[10]; // energy type name typedef EnergyType * PEnergyType; // pointer to energy type name // do not forget update this when change the above typedefs: #define MaxMMDBNameLength 40 typedef char maxMMDBName[MaxMMDBNameLength]; // ===================== constants =============================== // ANY_RES should be used in selection functions for specifying // "any residue" to select #define ANY_RES MinInt4 // PRNK_XXXXX are the print keys. PRNK_Silent supresses all print // inside mmdb_xxxx unless specifically ordered or catastrophic. // PRNK_SimRWBROOK instructs mmdb to issue, whenever possible and // necessary, printouts and warnings of RWBROOK (fortran) package. #define PRNK_Silent 0 #define PRNK_SimRWBROOK 1 // Error_XXXX may be returned by XX::ConvertPDBString() and GetCIF(..) // functions. // Error_WrongSection is returned if the string passed into function // does not belong to the corresponding PDB section. #define Error_NoError 0 #define Error_Ok 0 #define Error_WrongSection 1 #define Error_WrongChainID 2 #define Error_WrongEntryID 3 // Error_SEQRES_serNum is returned by CSeqRes::ConvertPDBASCII() if // serial numbers of SEQRES records do not increment by 1 #define Error_SEQRES_serNum 4 // Error_SEQRES_numRes is returned by CSeqRes::ConvertPDBASCII() if // SEQRES records show different number of residues #define Error_SEQRES_numRes 5 // Error_SEQRES_extraRes is returned by CSeqRes::ConvertPDBASCII() if // SEQRES contains more residues than specified #define Error_SEQRES_extraRes 6 #define Error_NCSM_Unrecognized 7 #define Error_NCSM_AlreadySet 8 #define Error_NCSM_WrongSerial 9 #define Error_NCSM_UnmatchIG 10 #define Error_ATOM_Unrecognized 11 #define Error_ATOM_AlreadySet 12 #define Error_ATOM_NoResidue 13 #define Error_ATOM_Unmatch 14 #define Error_CantOpenFile 15 #define Error_UnrecognizedInteger 16 #define Error_WrongModelNo 17 #define Error_DuplicatedModel 18 #define Error_NoModel 19 #define Error_ForeignFile 20 #define Error_WrongEdition 21 // CIF specific #define Error_NotACIFFile 22 #define Error_NoData 23 #define Error_UnrecognCIFItems 24 #define Error_MissingCIFField 25 #define Error_EmptyCIFLoop 26 #define Error_UnexpEndOfCIF 27 #define Error_MissgCIFLoopField 28 #define Error_NotACIFStructure 29 #define Error_NotACIFLoop 30 #define Error_UnrecognizedReal 31 #define Error_NoSheetID 32 #define Error_WrongSheetID 33 #define Error_WrongStrandNo 34 // Error_WrongNumberOfStrands may be issued when reading // sheet data from CIF #define Error_WrongNumberOfStrands 35 // Error_WrongSheetOrder may be issued when reading // sheet data from CIF #define Error_WrongSheetOrder 36 // Error_HBondInconsistency may be issued when reading // sheet data from CIF #define Error_HBondInconsistency 37 // Error_EmptyResidueName is issued when PDB ATOM record // does not have a residue name #define Error_EmptyResidueName 38 // Error_DuplicateSeqNum is issued when PDB ATOM records // show the sequence number and insertion code assigned // to more than one residue name #define Error_DuplicateSeqNum 39 // Error_NoLogicalName may be returned by file i/o functions // if the specified environmental variable for file name // is not found. #define Error_NoLogicalName 40 // Error_EmptyFile may be returned at reading non-existing // coordinate files #define Error_EmptyFile 41 // Error_CIF_EmptyRow is the event of encountering // an empty row in _atom_site loop. It is handled // internally and has no effect on API #define Error_CIF_EmptyRow 99999 #define Error_GeneralError1 10000 // ClassID_XXXX are used by container classes for proper // creating containered classes when reading from binary file. enum ClassID { ClassID_Template , ClassID_String , ClassID_ObsLine , ClassID_TitleLine , ClassID_CAVEAT , ClassID_Compound , ClassID_Source , ClassID_ExpData , ClassID_MdlType , ClassID_Author , ClassID_RevData , ClassID_Supersede , ClassID_Journal , ClassID_Remark , ClassID_DBReference, ClassID_SeqAdv , ClassID_ModRes , ClassID_Het , ClassID_NCSMatrix , ClassID_TVect , ClassID_Helix , ClassID_Turn , ClassID_Link , ClassID_LinkR , ClassID_CisPep }; // ===================== classes =============================== DefineClass(CAtom) DefineClass(CResidue) DefineClass(CChain) DefineClass(CModel) DefineClass(CMMDBManager) #endif mmdb-1.25.5/mmdb/mmdb_align.h0000775000175000017500000001255711736610510012644 00000000000000// $Id: mmdb_align.h,v 1.21 2012/01/26 17:52:20 ekr Exp $ // ================================================================= // // CCP4 Coordinate Library: support of coordinate-related // functionality in protein crystallography applications. // // Copyright (C) Eugene Krissinel 2000-2008. // // This library is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // // ================================================================= // // 19.04.11 <-- Date of Last Modification. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ----------------------------------------------------------------- // // **** Module : MMDB_Align // ~~~~~~~~~ // **** Classes : CAlignment ( alignment of character strings ) // ~~~~~~~~~~~~ CAlignment1 ( alignment of integer vectors ) // // (C) E.Krissinel' 2000-2011 // // ================================================================= // #ifndef __MMDB_Align__ #define __MMDB_Align__ #ifndef __Stream__ #include "stream_.h" #endif // ===================== CAlignParams ====================== DefineClass(CAlignParams); DefineStreamFunctions(CAlignParams); class CAlignParams : public CStream { public : realtype gapWeight,spaceWeight; realtype equalScore,nequalScore; int method; CAlignParams(); CAlignParams ( RPCStream Object ); void write ( RCFile f ); void read ( RCFile f ); protected : void InitAlignParams(); }; // ===================== CAlignment ====================== DefineClass(CAlignment); #define ALIGN_GLOBAL 0 #define ALIGN_LOCAL 1 #define ALIGN_GLOBLOC 2 #define ALIGN_FREEENDS 3 class CAlignment : public CStream { public : CAlignment (); CAlignment ( RPCStream Object ); ~CAlignment (); void SetAffineModel ( realtype WGap, realtype WSpace ); void SetScores ( realtype SEqual, realtype SNEqual ); void Align ( cpstr S, cpstr T, int Method=ALIGN_GLOBAL ); pstr GetAlignedS() { return AlgnS; } pstr GetAlignedT() { return AlgnT; } realtype GetScore () { return VAchieved; } char GetSpace () { return Space; } realtype GetSimilarity(); // Score-weighted sequence id realtype GetSeqId (); // Primitive sequence id virtual void OutputResults ( RCFile f, cpstr S, cpstr T ); void read ( RCFile f ); void write ( RCFile f ); protected : char Space; int AlignKey, SLen,TLen; rmatrix VT,ET,FT; pstr AlgnS,AlgnT; realtype VAchieved; realtype SEq,SNEq, Wg,Ws; virtual void InitAlignment(); virtual void FreeMemory (); virtual realtype Score ( char A, char B ); void BuildGATable ( cpstr S, cpstr T, Boolean FreeSEnd, Boolean FreeTEnd ); void BuildLATable ( cpstr S, cpstr T ); void Backtrace ( cpstr S, cpstr T, int J, int I, Boolean StopAtZero ); void AdjustEnds ( cpstr S, cpstr T, int J, int I ); void PrintVT ( cpstr S, cpstr T ); }; // ===================== CAlignment1 ====================== DefineClass(CAlignment1); class CAlignment1 : public CStream { public : CAlignment1 (); CAlignment1 ( RPCStream Object ); ~CAlignment1(); void SetAffineModel ( realtype WGap, realtype WSpace ); void SetScores ( realtype SEqual, realtype SNEqual ); void Align ( ivector S, int SLength, ivector T, int TLength, int Method=ALIGN_GLOBAL ); ivector GetAlignedS () { return AlgnS; } ivector GetAlignedT () { return AlgnT; } int GetAlignLength() { return AlgnLen; } realtype GetScore () { return VAchieved; } realtype GetSimilarity(); // Score-weighted sequence id virtual void OutputResults ( RCFile f, ivector S, int lenS, ivector T, int lenT ); void read ( RCFile f ); void write ( RCFile f ); protected : int Space; int AlignKey, SLen,TLen, AlgnLen; rmatrix VT,ET,FT; ivector AlgnS,AlgnT; realtype VAchieved; realtype SEq,SNEq, Wg,Ws; virtual void InitAlignment1(); virtual void FreeMemory (); virtual realtype Score ( int A, int B ); void BuildGATable ( ivector S, ivector T, Boolean FreeSEnds, Boolean FreeTEnds ); void BuildLATable ( ivector S, ivector T ); void Backtrace ( ivector S, ivector T, int J, int I, Boolean StopAtZero ); void AdjustEnds ( ivector S, ivector T, int J, int I ); void PrintVT ( ivector S, ivector T ); }; #endif mmdb-1.25.5/mmdb/mmdb_tables.h0000775000175000017500000001016111736610510013011 00000000000000// $Id: mmdb_tables.h,v 1.26 2012/01/26 17:52:21 ekr Exp $ // ================================================================= // // CCP4 Coordinate Library: support of coordinate-related // functionality in protein crystallography applications. // // Copyright (C) Eugene Krissinel 2000-2008. // // This library is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // // ================================================================= // // 04.02.09 <-- Date of Last Modification. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ----------------------------------------------------------------- // // **** Module : MMDBF_Tables // ~~~~~~~~~ // **** Project : MacroMolecular Data Base (MMDB) // ~~~~~~~~~ // // **** Functions : // ~~~~~~~~~~~ // // **** Constants : AName ( array of 2-character atom names ) // ~~~~~~~~~~~ HAName ( array of 2=character heteroatom names ) // RName ( 3-characters amino acid names ) // RName1 ( 1-characters amino acid names ) // // // (C) E. Krissinel 2000-2009 // // ================================================================= // #ifndef __MMDB_Tables__ #define __MMDB_Tables__ #ifndef __MatType__ #include "mattype_.h" #endif // ================================================================= #define nElementNames 117 #define nElementMetals 91 #define nHydAtomNames 14 extern cpstr const ElementName [nElementNames]; extern cpstr const ElementMetal [nElementMetals]; extern cpstr const HydAtomName [nHydAtomNames]; extern realtype const MolecWeight [nElementNames]; extern realtype const CovalentRadius[nElementNames]; extern realtype const VdWaalsRadius [nElementNames]; extern realtype const IonicRadius [nElementNames]; extern Boolean isMetal ( cpstr element ); #define ELEMENT_UNKNOWN -1 extern int getElementNo ( cpstr element ); extern realtype getMolecWeight ( cpstr element ); extern realtype getCovalentRadius ( cpstr element ); extern realtype getVdWaalsRadius ( cpstr element ); #define nResNames 26 extern cpstr const ResidueName [nResNames]; extern char const ResidueName1[nResNames]; extern int getResidueNo ( cpstr resName ); #define nSolventNames 12 #define nAminoacidNames 23 #define nNucleotideNames 24 DefineStructure(SAAProperty) struct SAAProperty { char name[4]; realtype hydropathy; realtype charge; realtype relSolvEnergy; }; extern SAAProperty const AAProperty[nAminoacidNames]; extern int const AASimilarity[nAminoacidNames][nAminoacidNames]; extern int GetAAPIndex ( cpstr resName ); // 0..nAminoacidNames-1 extern realtype GetAAHydropathy ( cpstr resName ); // -4.5...+4.5 extern realtype GetAACharge ( cpstr resName ); extern realtype GetAASolvationEnergy ( cpstr resName ); extern int GetAASimilarity ( cpstr resName1, cpstr resName2 ); // 0..5 extern cpstr const StdSolventName[nSolventNames]; //extern pstr const AminoacidName [nAminoacidNames]; extern cpstr const NucleotideName[nNucleotideNames]; extern Boolean isSolvent ( cpstr resName ); extern Boolean isAminoacid ( cpstr resName ); extern Boolean isNucleotide ( cpstr resName ); extern int isDNARNA ( cpstr resName ); // 0,1(DNA),2(RNA) extern Boolean isSugar ( cpstr resName ); extern void Get1LetterCode ( cpstr res3name, pstr res1code ); extern void Get3LetterCode ( cpstr res1name, pstr res3code ); #endif mmdb-1.25.5/mmdb/mmdb_mmcif.h0000775000175000017500000026105012102473202012630 00000000000000// $Id: mmdb_mmcif.h,v 1.23 2012/01/26 17:52:20 ekr Exp $ // ================================================================= // // CCP4 Coordinate Library: support of coordinate-related // functionality in protein crystallography applications. // // Copyright (C) Eugene Krissinel 2000-2008. // // This library is free software: you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License version 3, modified in accordance with the provisions // of the license to address the requirements of UK law. // // You should have received a copy of the modified GNU Lesser // General Public License along with this library. If not, copies // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php // // 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 Lesser General Public License for more details. // // ================================================================= // // 16.01.13 <-- Date of Last Modification. // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ----------------------------------------------------------------- // // **** Module : MMDB_MMCIF // ~~~~~~~~~ // **** Project : MacroMolecular Data Base (MMDB) // ~~~~~~~~~ // **** Classes : CMMCIFCategory ( mmCIF category ) // ~~~~~~~~~ CMMCIFStruct ( mmCIF structure ) // CMMCIFLoop ( mmCIF loop ) // CMMCIFData ( mmCIF data block ) // CMMCIFFile ( mmCIF file ) // // (C) E. Krissinel 2000-2013 // // ================================================================= // #ifndef __MMDB_MMCIF__ #define __MMDB_MMCIF__ #ifndef __Stream__ #include "stream_.h" #endif // ====================== CMMCIFCategory ========================== #define MMCIF_Category 0 #define MMCIF_Struct 1 #define MMCIF_Loop 2 #define MMCIF_Data 3 DefineClass(CMMCIFCategory) DefineStreamFunctions(CMMCIFCategory) /// \brief CMMCIFCategory is a base class for CMMCIFStruct and /// CMMCIFLoop, implementations of mmCIF's "structure" and /// "loop" categories. /*! This class is not instantiated independently in any applications, however, it provides a few public functions which work for both CMMCIFStruct and CMMCIFLoop. All data in mmCIF hierarchy is addressed using construct "category.tag" plus row number (>=0) for loops. Category names should always start from underscore, while tags normally start with a letter, e.g. "_barrel.id". See general principles of working with mmCIF files and mmCIF hierarchies in Section \"\ref mmcif_handler\". */ class CMMCIFCategory : public CStream { friend class CMMCIFData; public : /// \brief Basic constructor. CMMCIFCategory (); /// \brief Constructor that assigns category name. /// \param[in] N category name (must start with underscore). CMMCIFCategory ( cpstr N ); /// \brief Constructor for MMDB data streaming functions. CMMCIFCategory ( RPCStream Object ); /// \brief Destructor. ~CMMCIFCategory(); /// \brief Returns category name. /// \return NULL if name was not set /// \return pointer to character string if name was set pstr GetCategoryName() { return name; } /// \brief Sets category name. /// \param N new category name void SetCategoryName ( cpstr N ); /// \brief Returns category type. /// This function may be used when retrieving categories /// (structures and loops) from data blocks (CMMCIFData). /// \return MMCIF_Category for CMMCIFCategory /// \return MMCIF_Struct for CMMCIFStruct /// \return MMCIF_Loop for CMMCIFLoop virtual int GetCategoryID() { return MMCIF_Category; } /// \brief Virtual function for writing category's content /// into mmCIF file. /// Default implementation does nothing. virtual void WriteMMCIF ( RCFile ) {} /// \brief Virtual function for optimizig data structures. /// Optimized data structures take less RAM and their indexes /// are sorted for quicker access. Sorting is done automatically /// as new data is added to the category. If the /// category is edited (fields/data removed), it may need /// optimization and re-sorting for efficiency.\n\n /// The sorting preserves the order of actual appearance of /// tags in mmCIF file. If a category is created /// programmatically, the order of tags in mmCIF file will be /// the same as order of adding them to the category. virtual void Optimize(); /// \brief Sorts category's data for quicker access. /// The sorting is essentially re-indexing of data for quicker /// access. It does not change the order of data in both mmCIF /// hierarchy and mmCIF file. E.g., if tag "serial_no" was 2nd /// one in given category before sorting, it will remain on 2nd /// place after it, therefore no change in tag number passed /// to functions in CMMCIFStruct, CMMCIFLoop and CMMCIFData. void Sort(); /// \brief Returns serial number of a tag in the category. /// \param[in] ttag tag (or name of a field in category) /// \return \b >=0 : the tag is in given position /// \return \b <0 : the tag was not found, but it could be /// inserted before tag with (-rc-1)th index, where /// 'rc' is the return. int GetTagNo ( cpstr ttag ); /// \brief Adds a tag to the category. /// Adding a tag in CMMCIFCategory does not reserve any /// placeholder for the corresponding value. All tags get /// automatically sorted (reindexed) for quicker access. /// Tags will appear in mmCIF file in order of their addition /// to the category. /// \param[in] ttag tag to be added. /// \return \b >=0 the tag is already in the category, and return /// is its serial number. No changes to the category /// is done /// \return \b <0 the tag was added to the list of tags, and /// return is minus total number of tags in the /// category. int AddTag ( cpstr ttag ); /// \brief Returns the total number of tags in the category int GetNofTags() { return nTags; } /// \brief Returns tag with the specified serial number. /// The tags are enumerated as 0..GetNofTags()-1. /// \param tagNo tag's serial number /// \return \b NULL: tagNo is outside the range /// of 0..GetNofTags()-1 /// \return \b not \b NULL: tag in tagNo'th position pstr GetTag ( int tagNo ); // 0..nTags-1 /// \brief Prints list of tags to stdout. /// Both sorted and unsorted tags are printed to standard /// output. This function may be used for debugging. void PrintTags(); /// \brief Returns True if all tags from the list are found /// in the category. /// The size of the list of tags may be less than the number /// of tags in the category, and order of tags is disregarded. /// \param[in] tagList list of tags to be checked for presence /// in the category. The list must end with NULL /// pointer, or your program will crash. /// \return \b True if all tags from the list were found in the /// category /// \return \b False if one or more tags from the list were not /// found in the category. /// /// Example: /// \code /// cpstr tagList[] = {"id","type","date",NULL}; /// CMMCIFStruct cifStruct; /// if (cifStruct.CheckTags(tagList)) /// printf ( " all tags are found in category %s\n", /// cifStruct.GetCategoryName() ); /// \endcode /// This function is useful for finding categories in /// "dirty cifs", where category name is not given. Boolean CheckTags ( cpstr * tagList ); /// \brief Deep copy of categories. /// Deep copy duplicates all data and memory allocations, /// producing a genuine clone of the original. Only deep copy /// should be used for copying MMDB objects, a mere assignment /// operator will fail you. /// \param[in] Category a pointer to CMMCIFCategory, the content of /// which is copied into 'this' category. virtual void Copy ( PCMMCIFCategory Category ); /// \brief MMDB stream writer. void write ( RCFile f ); /// \brief MMDB stream reader. void read ( RCFile f ); protected: int nTags; pstr name; psvector tag; ivector index; int nAllocTags; void InitMMCIFCategory (); virtual void FreeMemory (); void ExpandTags ( int nTagsNew ); void PutCategoryName ( cpstr newName ); }; // ====================== CMMCIFStruct ============================ DefineClass(CMMCIFStruct) DefineStreamFunctions(CMMCIFStruct) /// \brief Constants used to specify mmCIF's \"data not given\" and /// \"data not available\" data types. #define CIF_NODATA_DOT 0 #define CIF_NODATA_QUESTION 1 #define CIF_NODATA_DOT_FIELD pstr("\x02" ".") #define CIF_NODATA_QUESTION_FIELD pstr("\x02" "?") /// \brief CMMCIFStruct represents mmCIF's \"structure\" category, /// where data follows directly the corresponding tag. /*! mmCIF's \"structure\" category has the following form: \code _structure_name.tag0 value0 _structure_name.tag1 value1 ........... _structure_name.tagN valueN \endcode CMMCIFStruct represents this construct by keeping category name (\"_structure_name\") and associated lists of tags (\"tag0,tag1...tagN\") and their values (\"value0,value1...valueN\"). The structure is created automatically when an mmCIF file is read, or it may be created programatically and then pushed into file. Access to data is provided via tags. Internally, all values are kept as character fields, and it is only on the retrieval stage that they are converted to other data types (integers, floats or strings). If conversion is not possible, an error code is returned by the corresponding functions, which should be checked by the application. See general principles of working with mmCIF files and mmCIF hierarchies, as well as some code samples, in Section \"\ref mmcif_handler\". */ class CMMCIFStruct : public CMMCIFCategory { public : /// \brief Basic constructor CMMCIFStruct (); /// \brief Constructor that assigns structure name. /// \param[in] N structure name (must start with underscore). CMMCIFStruct ( cpstr N ); /// \brief Constructor for MMDB data streaming functions CMMCIFStruct ( RPCStream Object ); /// \brief Destructor ~CMMCIFStruct(); /// \brief Adds field to the structure. /// \param[in] F field value /// \param[in] T tag name /// \param[in] Concatenate flag to concatenate existing field /// with the value of \b F. If tag \b T is already in /// the structure and \b Concatenate=True, then /// value of \b F is appended to the existing field. /// Otherwise, the field is replaced with the value /// of \b F void AddField ( cpstr F, cpstr T, Boolean Concatenate=False ); /// \brief Returns category type \b MMCIF_Struct. int GetCategoryID() { return MMCIF_Struct; } /// \brief Optimizes structure for RAM and data access speed. /// Optimized data structures take less RAM and their indexes /// are sorted for quicker access. Sorting is done automatically /// as new data is added to the category. If the structure /// is edited (fields/data removed), it may need /// optimization and re-sorting for efficiency.\n\n /// The sorting preserves the order of actual appearance of /// tags in mmCIF file. If a structure is created /// programmatically, the order of tags in mmCIF file will be /// the same as order of adding them to the structure. void Optimize(); /// \brief Returns value of field corresponding to tag in the /// specified position. /// Tag positions are defined by the order of their appearance in /// mmCIF file (if structure was read from a file), or by the /// order of their addition to the structure (if structure was /// created programmatically). Tags are numbered as /// 0...GetNofTags()-1. /// \param[in] tagNo tag number (position in the structure) /// \return \b NULL: tag does not exist /// \return \b CIF_NODATA_DOT_FIELD the field contains /// \"data not given\" value /// \return \b CIF_NODATA_QUESTION_FIELD the field contains /// \"data not available\" value /// \return \b not \b NULL: string value of the field pstr GetField ( int tagNo ); // 0..nTags-1 /// \brief Fetches value, corresponding to the given tag, as /// a string /// \param[out] S pointer to string, which will point to newly /// allocated character string, containing value /// associated with tag \b TName. If tag or value /// is not found, or if value corresponds to /// mmCIF's \"data not given\" or /// \"data not available\", \b S returns NULL. /// \param[in] TName character string with tag name /// \param[in] Remove flag to remove the tag and its value from /// structure after it is read. /// \return \b CIFRC_NoTag: tag is not found /// \return \b CIFRC_NoField: value is not found /// \return \b CIFRC_Ok: success. If \b S returns NULL, then /// the value corresponds to either /// \"data not available\" or /// \"data not given\". /// \remarks If \b S!=NULL at time of call, the function will /// try to dispose the string it points on. This allows a slick /// re-use of the same pointer in consequitive calls. This also /// means that one should never pass unallocated pointer to /// this function. Safe use assumes the following patern: /// \code /// CMMCIFStruct mmCIFStruct; /// pstr S; // this is merely "char *S" /// int rc; /// /// S = NULL; // null pointer before first use /// rc = mmCIFStruct.GetString ( S,"id" ); /// if (rc) CreateCopy ( S,"*** data not found" ); /// if (!S) CreateCopy ( S,"*** data not given or not available" ); /// printf ( " rc=%i, S='%s'\n",rc,S ); /// /// rc = mmCIFStruct.GetString ( S,"property" ); /// if (rc) CreateCopy ( S,"*** data not found" ); /// if (!S) CreateCopy ( S,"*** data not given or not available" ); /// printf ( " rc=%i, S='%s'\n",rc,S ); /// /// // etc etc etc /// /// delete[] S; // application is responsible for final /// // disposal of memory /// \endcode int GetString ( pstr & S, cpstr TName, Boolean Remove=False ); /// \brief Returns pointer to value associated with given tag. /// \param[in] TName character string with tag name /// \param[out] RC return code: /// \arg \b CIFRC_NoTag: tag is not found /// \arg \b CIFRC_NoField: value is not found /// \arg \b CIFRC_Ok: success. If function returns NULL, then /// the value corresponds to either /// \"data not available\" or /// \"data not given\". /// \return \b NULL: either tag or value is not found, or the /// value is \"data not available\" or \"data not given\". /// Read return code \b RC in order to interpret NULL return. /// \return \b not \b NULL: pointer (\c char \c *) to value /// associated with \b TName. /// \remarks Never try to dispose memory pointed by the return /// value, or your program will crash. pstr GetString ( cpstr TName, int & RC ); // NULL if TName // is not there /// \brief Deletes field associated with given tag. /// \param[in] TName character string with tag name /// \return \b >=0: field deleted /// \return \b <0: either field or tag is not found int DeleteField ( cpstr TName ); // <0 the field was not there /// \brief Fetches value, corresponding to the given tag, as /// a real number. /// \param[out] R reference to real number to accept the value. /// In case of failure, \b R returns zero. /// \param[in] TName character string with tag name /// \param[in] Remove flag to remove the tag and its value from /// structure after it is read. /// \return \b CIFRC_NoTag: tag is not found /// \return \b CIFRC_NoField: field is not found /// \return \b CIFRC_WrongFormat: value is not a real or integer /// number. /// \return \b CIFRC_NoData: value is either /// \"data not available\" or /// \"data not given\". /// \return \b CIFRC_Ok: success. int GetReal ( realtype & R, cpstr TName, Boolean Remove=False ); /// \brief Fetches value, corresponding to the given tag, as /// an integer number. /// \param[out] I reference to integer number to accept the /// value. In case of failure, \b I returns zero, except /// when value is \"data not available\" or /// \"data not given\", when I returns \c MinInt4. /// \param[in] TName character string with tag name /// \param[in] Remove flag to remove the tag and its value from /// structure after it is read. /// \return \arg \b CIFRC_NoTag: tag is not found /// \return \b CIFRC_NoField: field is not found /// \return \b CIFRC_WrongFormat: value is not an integer number. /// \return \b CIFRC_NoData: value is either /// \"data not available\" or /// \"data not given\". /// \return \b CIFRC_Ok: success. int GetInteger ( int & I, cpstr TName, Boolean Remove=False ); /// \brief Sets string value for given tag. /// \param[in] S character string with value to be set. /// If \b S==NULL, the \"data not given\" value /// will be set. If \b S==\"\" (empty string), the /// \"data not available\" value is stored. /// \param[in] TName character string with tag name. If tag /// is not found, it will be added to the structure. /// \param[in] NonBlankOnly flag to treat white-space-only /// strings: /// \arg \b False: set as is /// \arg \b True: set \"data not available\" value instead. void PutString ( cpstr S, cpstr TName, Boolean NonBlankOnly=False ); /// \brief Sets current date in format YYYY-MM-DD as a value /// for given tag. /// \param[in] T character string with tag name. If tag /// is not found, it will be added to the structure. void PutDate ( cpstr T ); /// \brief Sets \"data not given\" or \"data not available\" /// values for given tag. /// \param[in] NoDataType can be either /// \arg \b CIF_NODATA_DOT for \"data not given\" /// \arg \b CIF_NODATA_QUESTION for \"data not available\" /// \param[in] T character string with tag name. If tag /// is not found, it will be added to the structure. void PutNoData ( int NoDataType, cpstr T ); /// \brief Sets float-point value for given tag. /// \param[in] R real number with value to be set. /// \param[in] TName character string with tag name. If tag /// is not found, it will be added to the structure. /// \param[in] prec float-point precision; g-format with given /// precision will be used void PutReal ( realtype R, cpstr TName, int prec=8 ); /// \brief Sets float-point value for given tag. /// \param[in] R real number with value to be set. /// \param[in] TName character string with tag name. If tag /// is not found, it will be added to the structure. /// \param[in] format format string to convert \b R. void PutReal ( realtype R, cpstr TName, cpstr format ); /// \brief Sets integer value for given tag. /// \param[in] I integer number with value to be set. /// \param[in] TName character string with tag name. If tag /// is not found, it will be added to the structure. void PutInteger ( int I, cpstr TName ); /// \brief Writes structure data in mmCIF format into file. /// \param[in] FName character string with file name. /// \param[in] gzipMode flag to controll compression of files: /// \arg \b GZM_NONE: do not compress /// \arg \b GZM_CHECK: check file name suffix and compress /// (or not) accordingly /// \arg \b GZM_ENFORCE_GZIP: force gzip compression despite /// suffix /// \arg \b GZM_ENFORCE_COMPRESS: force using compress despite /// suffix /// \return \b True: success /// \return \b False: can not open file for writing. /// \remarks This function does not create a valid mmCIF file /// as \"data_XXX\" record will be missing. It may be used for /// debugging though. Boolean WriteMMCIFStruct ( cpstr FName, byte gzipMode=GZM_CHECK ); /// \brief Writes structure into given file. /// \param f reference to MMDB's file class. The file should be /// opened and closed by application. /// \remarks There is a very limited use of this function on /// application level. It is primarily used by CMMCIFData class. void WriteMMCIF ( RCFile f ); /// \brief Deep copy of structures. /// Deep copy duplicates all data and memory allocations, /// producing a genuine clone of the original. Only deep copy /// should be used for copying MMDB objects, a mere assignment /// operator will fail you. /// \param[in] Struct a pointer to CMMCIFStruct, the content of /// which is copied into 'this' structure. void Copy ( PCMMCIFCategory Struct ); /// \brief MMDB stream writer. void write ( RCFile f ); /// \brief MMDB stream reader. void read ( RCFile f ); protected: psvector field; void InitMMCIFStruct(); void FreeMemory(); }; // ====================== CMMCIFLoop ============================== DefineClass(CMMCIFLoop) DefineStreamFunctions(CMMCIFLoop) /// \brief CMMCIFLoop represents mmCIF's \"loop\" category, which keeps /// rows of data values associated with tags. /*! mmCIF's \"loop\" category has the following form: \code loop_ _loop_name.tag0 value0 _loop_name.tag1 value1 ........... _loop_name.tagN valueN value00 value10 ... valueN0 value01 value11 ... valueN1 ........... value0M value1M ... valueNM \endcode CMMCIFLoop represents this construct by keeping category name (\"_loop_name\") and associated lists of tags (\"tag0,tag1...tagN\") and data vectors (\"[value00...value0M],[value10...value1M]...[valueN0...valueNM]\"). The loop object is created automatically when an mmCIF file is read, or it may be created programatically and then pushed into file. Access to data is provided via tags and data indexes. Internally, all values are kept as character fields, and it is only on the retrieval stage that they are converted to other data types (integers, floats or strings). If conversion is not possible, an error code is returned by the corresponding functions, which should be checked by the application. The following code gives an example of creating mmCIF loop category and populating it with data: \code CMMCIFLoop loop; char S[100]; int i; // Specify loop name: loop.SetCategoryName ( "_sample_loop" ); // Create loop structure, i.e., list of tags first: loop.AddLoopTag ( "id" ); loop.AddLoopTag ( "name" ); loop.AddLoopTag ( "value" ); // Now populate it with data. This my be done in 2 ways. // Here is how you write loop data in stream fashion, // value-after-value: for (i=0;i<3;i++) { loop.AddInteger ( i ); sprintf ( S,"1st_way-%i",i ); loop.AddString ( S ); loop.AddReal ( 2.5*(i+1) ); } // Here is how you populate loop data using direct-access // functions: for (i=3;i<6;i++) { loop.PutReal ( 2.5*(i+1),"value",i ); loop.PutInteger ( i,"id" ); sprintf ( S,"2nd way: %i",i ); loop.PutString ( S,"name" ); } loop.WriteMMCIFLoop ( "sample_loop.cif" ); \endcode The resulting file \b sample_loop.cif will contain: \code loop_ _sample_loop.id _sample_loop.name _sample_loop.value 0 1st_way-0 2.5 1 1st_way-1 5.0 2 1st_way-2 7.5 3 "2nd way: 3" 10.0 4 "2nd way: 4" 12.5 5 "2nd way: 5" 15.0 \endcode See general principles of working with mmCIF files and mmCIF hierarchies, as well as some code samples, in Section \"\ref mmcif_handler\". */ class CMMCIFLoop : public CMMCIFCategory { friend class CMMCIFData; public : /// \brief Basic constructor CMMCIFLoop (); /// \brief Constructor that assigns structure name. /// \param[in] N structure name (must start with underscore). CMMCIFLoop ( cpstr N ); /// \brief Constructor for MMDB data streaming functions CMMCIFLoop ( RPCStream Object ); /// \brief Destructor ~CMMCIFLoop(); /// \brief Adds tag to the loop. /// The tag is appended to the list of existing tags. The order /// of tags cannot be changed. /// \param[in] T tag name /// \param[in] Remove flag to remove all fields in the loop. void AddLoopTag ( cpstr T, Boolean Remove=True ); /// \brief Sets string value at current loop position. /// When \b CMMCIFLoop::Add[Data] functions use internal loop /// pointer. When category is created or cleared (by using /// \b CMMCIFTLoop::AddLoopTag ( T,True )) the pointer is set to /// 0th row and 0th column (tag). After each call to /// \b CMMCIFLoop::Add[Data] function, internal pointer advances /// to next column (tag), and wraps over to next row, 0th tag, /// if list of tags is exhausted. Any remaining fields in last /// row will be populated with \"data not given\" value. /// \param[in] S character string with value to be set. /// If \b S==NULL, the \"data not given\" value /// will be set. If \b S==\"\" (empty string), the /// \"data not available\" value is stored. /// \param[in] NonBlankOnly flag to treat white-space-only /// strings: /// \arg \b False: set as is /// \arg \b True: set \"data not available\" value instead. void AddString ( cpstr S, Boolean NonBlankOnly=False ); /// \brief Sets \"data not given\" or \"data not available\" at /// current loop position. /// When \b CMMCIFLoop::Add[Data] functions use internal loop /// pointer. When category is created or cleared (by using /// \b CMMCIFTLoop::AddLoopTag ( T,True )) the pointer is set to /// 0th row and 0th column (tag). After each call to /// \b CMMCIFLoop::Add[Data] function, internal pointer advances /// to next column (tag), and wraps over to next row, 0th tag, /// if list of tags is exhausted. Any remaining fields in last /// row will be populated with \"data not given\" value. /// \param[in] NoDataType integer key specifying which type of /// data absence should be set as a value: /// \arg \b CIF_NODATA_DOT for \"data not given\" /// \arg \b CIF_NODATA_QUESTION for \"data not available\" void AddNoData ( int NoDataType ); /// \brief Sets float-point value at current loop position. /// When \b CMMCIFLoop::Add[Data] functions use internal loop /// pointer. When category is created or cleared (by using /// \b CMMCIFTLoop::AddLoopTag ( T,True )) the pointer is set to /// 0th row and 0th column (tag). After each call to /// \b CMMCIFLoop::Add[Data] function, internal pointer advances /// to next column (tag), and wraps over to next row, 0th tag, /// if list of tags is exhausted. Any remaining fields in last /// row will be populated with \"data not given\" value. /// \param[in] R real number with value to be set. /// \param[in] prec float-point precision; g-format with given /// precision will be used void AddReal ( realtype R, int prec=8 ); /// \brief Sets float-point value at current loop position in /// given format. /// When \b CMMCIFLoop::Add[Data] functions use internal loop /// pointer. When category is created or cleared (by using /// \b CMMCIFTLoop::AddLoopTag ( T,True )) the pointer is set to /// 0th row and 0th column (tag). After each call to /// \b CMMCIFLoop::Add[Data] function, internal pointer advances /// to next column (tag), and wraps over to next row, 0th tag, /// if list of tags is exhausted. Any remaining fields in last /// row will be populated with \"data not given\" value. /// \brief Sets float-point value for given tag. /// \param[in] R real number with value to be set. /// \param[in] format format string to convert \b R. void AddReal ( realtype R, cpstr format ); /// \brief Sets integer value at current loop position in given /// format. /// When \b CMMCIFLoop::Add[Data] functions use internal loop /// pointer. When category is created or cleared (by using /// \b CMMCIFTLoop::AddLoopTag ( T,True )) the pointer is set to /// 0th row and 0th column (tag). After each call to /// \b CMMCIFLoop::Add[Data] function, internal pointer advances /// to next column (tag), and wraps over to next row, 0th tag, /// if list of tags is exhausted. Any remaining fields in last /// row will be populated with \"data not given\" value. /// \param[in] I integer number with value to be set. void AddInteger ( int I ); /// \brief Returns current length of the loop (i.e. the number /// of rows). /// \return number of data rows in the loop. int GetLoopLength() { return nRows; } /// \brief Returns string pointer on the field corresponding to /// tag in the specified position, in the specified row. /// Tag positions are defined by the order of their appearance in /// mmCIF file (if loop was read from a file), or by the /// order of their addition to the loop (if loop was /// created programmatically). /// \param[in] rowNo row number (0...GetLoopLength()-1) /// \param[in] tagNo tag number (0...GetNofTags()-1) /// \return \b NULL: tag or row do not exist /// \return \b CIF_NODATA_DOT_FIELD the field contains /// \"data not given\" value /// \return \b CIF_NODATA_QUESTION_FIELD the field contains /// \"data not available\" value /// \return \b not \b NULL: string value of the field /// \remarks Never try to dispose memory pointed by the return /// value, or your program will crash. pstr GetField ( int rowNo, int tagNo ); /// \brief Fetches value, corresponding to the given tag, in /// the given row, as a string /// \param[out] S pointer to string, which will point to newly /// allocated character string, containing value /// associated with tag \b TName and row \b nrow. /// If tag, row or value /// is not found, or if value corresponds to /// mmCIF's \"data not given\" or /// \"data not available\", \b S returns NULL. /// \param[in] TName character string with tag name /// \param[in] nrow row number (0...GetLoopLength()-1) /// \param[in] Remove flag to remove the field from /// structure after it is read. /// \return \b CIFRC_NoTag: tag is not found /// \return \b CIFRC_WrongIndex: row is not found /// \return \b CIFRC_NoField: value is not found /// \return \b CIFRC_Ok: success. If \b S returns NULL, then /// the value corresponds to either /// \"data not available\" or /// \"data not given\". /// \remarks If \b S!=NULL at time of call, the function will /// try to dispose the string it points on. This allows a slick /// re-use of the same pointer in consequitive calls. This also /// means that one should never pass unallocated pointer to /// this function. Safe use assumes the following patern: /// \code /// CMMCIFLoop mmCIFLoop; /// pstr S; // this is merely "char *S" /// int rc; /// /// S = NULL; // null pointer before first use /// rc = mmCIFLoop.GetString ( S,"id",1 ); /// if (rc) CreateCopy ( S,"*** data not found" ); /// if (!S) CreateCopy ( S,"*** data not given or not available" ); /// printf ( " rc=%i, S='%s'\n",rc,S ); /// /// rc = mmCIFLoop.GetString ( S,"property",0 ); /// if (rc) CreateCopy ( S,"*** data not found" ); /// if (!S) CreateCopy ( S,"*** data not given or not available" ); /// printf ( " rc=%i, S='%s'\n",rc,S ); /// /// // etc etc etc /// /// delete[] S; // application is responsible for final /// // disposal of memory /// \endcode int GetString ( pstr & S, cpstr TName, int nrow, Boolean Remove=False ); /// \brief Returns pointer to value associated with given tag, /// in the given row of the loop. /// \param[in] TName character string with tag name /// \param[in] nrow row number (0...GetLoopLength()-1) /// \param[out] RC return code: /// \arg \b CIFRC_NoTag: tag is not found /// \arg \b CIFRC_WrongIndex: row is not found /// \arg \b CIFRC_NoField: value is not found /// \arg \b CIFRC_Ok: success. If function returns NULL, then /// the value corresponds to either /// \"data not available\" or /// \"data not given\". /// \return \b NULL: either tag, row or value is not found, or the /// value is \"data not available\" or \"data not given\". /// Read return code \b RC in order to interpret NULL return. /// \return \b not \b NULL: pointer (\c char \c *) to value /// associated with \b TName. /// \remarks Never try to dispose memory pointed by the return /// value, or your program will crash. pstr GetString ( cpstr TName, int nrow, int & RC ); /// \brief Copies value, associated with given tag, /// in the given row, into specified buffer. /// Terminating NULL character is appended. /// \param[out] buf character string to accept the value /// \param[in] maxlength maximum number of bytes to copy /// \param[in] TName character string with tag name /// \param[in] nrow row number (0...GetLoopLength()-1) /// \param[out] RC return code: /// \arg \b CIFRC_NoTag: tag is not found /// \arg \b CIFRC_WrongIndex: row is not found /// \arg \b CIFRC_NoField: value is not found /// \arg \b CIFRC_Ok: success. /// \remarks Destination string \b buf is not modified if /// \b RC!=CIFRC_Ok . void CopyString ( pstr buf, int maxlength, cpstr TName, int nrow, int & RC ); /// \brief Deletes field associated with given tag in /// the given row. /// \param[in] TName character string with tag name /// \param[in] nrow row number (0...GetLoopLength()-1) /// \return \b >=0: field deleted /// \return \b <0: either field or tag is not found int DeleteField ( cpstr TName, int nrow ); /// \brief Deletes all fields in given row. /// \param[in] nrow row number (0...GetLoopLength()-1) /// \return \b CIFRC_Ok: fields deleted /// \return \b CIFRC_WrongIndex: row not found /// \remarks Note that this function delets just the fields, but /// not the row. If you wish the row to be deleted, call /// CMMCIFLoop::Optimize() function after this one. int DeleteRow ( int nrow ); /// \brief Fetches value, corresponding to the given tag, /// in the given row, as a real number. /// \param[out] R reference to real number to accept the value. /// In case of failure, \b R returns zero. /// \param[in] TName character string with tag name /// \param[in] nrow row number (0...GetLoopLength()-1) /// \param[in] Remove flag to remove the field from /// the loop after it is read. /// \return \b CIFRC_NoTag: tag is not found /// \return \b CIFRC_WrongIndex: row not found /// \return \b CIFRC_NoField: field is not found /// \return \b CIFRC_WrongFormat: value is not a real or integer /// number. /// \return \b CIFRC_NoData: value is either /// \"data not available\" or /// \"data not given\". /// \return \b CIFRC_Ok: success. int GetReal ( realtype & R, cpstr TName, int nrow, Boolean Remove=False ); /// \brief Copies value, associated with given tag, /// in the given row, into specified destination as /// a real number. /// \param[out] R reference to real number to accept the value /// \param[in] TName character string with tag name /// \param[in] nrow row number (0...GetLoopLength()-1) /// \param[out] RC return code: /// \arg \b CIFRC_NoTag: tag is not found /// \arg \b CIFRC_WrongIndex: row is not found /// \arg \b CIFRC_NoField: value is not found /// \arg \b CIFRC_Ok: success. /// \remarks Destination \b R is set 0 if \b RC!=CIFRC_Ok. void CopyReal ( realtype & R, cpstr TName, int nrow, int & RC ); /// \brief Copies value, associated with given tag, /// in the given row, into specified destination as /// an integer number. /// \param[out] I reference to integer number to accept the value /// \param[in] TName character string with tag name /// \param[in] nrow row number (0...GetLoopLength()-1) /// \param[out] RC return code: /// \arg \b CIFRC_NoTag: tag is not found /// \arg \b CIFRC_WrongIndex: row is not found /// \arg \b CIFRC_NoField: value is not found /// \arg \b CIFRC_Ok: success. /// \remarks Destination \b I is set 0 if \b RC!=CIFRC_Ok. void CopyInteger ( int & I, cpstr TName, int nrow, int & RC ); /// \brief Fetches value, corresponding to the given tag, /// in the given row, as an integer number. /// \param[out] I reference to integer number to accept the value. /// In case of failure, \b R returns zero. /// \param[in] TName character string with tag name /// \param[in] nrow row number (0...GetLoopLength()-1) /// \param[in] Remove flag to remove the field from /// the loop after it is read. /// \return \b CIFRC_NoTag: tag is not found /// \return \b CIFRC_WrongIndex: row not found /// \return \b CIFRC_NoField: field is not found /// \return \b CIFRC_WrongFormat: value is not a real or integer /// number. /// \return \b CIFRC_NoData: value is either /// \"data not available\" or /// \"data not given\". /// \return \b CIFRC_Ok: success. int GetInteger ( int & I, cpstr TName, int nrow, Boolean Remove=False ); /// \brief Fetches set of values, corresponding to the given /// tag, in the given range of rows, as a vector of /// strings. /// \param[out] S reference to string vector to accept /// the values. if \b S==NULL , the vector will be /// allocated with starting index of \b i1. /// \param[in] TName character string with tag name /// \param[in] i1 minimum row number to fetch, the actual /// index will be calculated as \b max(0,min(i1,i2)) /// \param[in] i2 maximum row number to fetch, the actual /// index will be calculated as /// \b min(GetLoopLength()-1,max(i1,i2)) /// \param[in] Remove flag to remove fetched fields from /// the loop after they are read. /// \return \b CIFRC_NoTag: tag is not found /// \return \b CIFRC_WrongIndex: invalid range of rows /// \return \b CIFRC_Ok: success. /// /// For safe use, \b S should be pre-allocated by calling /// process. Only elements \b S[i1] to \b S[i2] will contain /// fetched data, others remain untouched. The calling /// process is responsible for the disposal of \b S. Example: /// \code /// CMMCIFLoop loop; /// psvector S; // equivalent to char **S /// int i,i1,i2,rc,n; /// /// // ... get loop data /// /// n = loop.GetLoopLength(); /// i1 = 5; i2 = n - 5; // could be wrong! /// /// // allocate vector of strings /// GetVectorMemory ( S,n,0 ); // "0" for starting index /// for (i=0;i